diff --git a/clients/cli/common.c b/clients/cli/common.c
index 1020201731..04ccf8dc1f 100644
--- a/clients/cli/common.c
+++ b/clients/cli/common.c
@@ -1296,8 +1296,7 @@ nmc_do_cmd (NmCli *nmc, const NMCCommand cmds[], const char *cmd, int argc, char
 	const NMCCommand *c;
 	gs_unref_object GTask *task = NULL;
 
-	task = g_task_new (NULL, NULL, command_done, nmc);
-	g_task_set_source_tag (task, nmc_do_cmd);
+	task = nm_g_task_new (NULL, NULL, nmc_do_cmd, command_done, nmc);
 	g_task_set_task_data (task, nmc, NULL);
 
 	if (argc == 0 && nmc->complete) {
diff --git a/introspection/org.freedesktop.NetworkManager.Settings.xml b/introspection/org.freedesktop.NetworkManager.Settings.xml
index f7be2717b8..0587db5f45 100644
--- a/introspection/org.freedesktop.NetworkManager.Settings.xml
+++ b/introspection/org.freedesktop.NetworkManager.Settings.xml
@@ -102,6 +102,7 @@
         LoadConnections:
         @filenames: Array of paths to on-disk connection profiles in directories monitored by NetworkManager.
         @status: Success or failure of the operation as a whole. True if NetworkManager at least tried to load the indicated connections, even if it did not succeed. False if an error occurred before trying to load the connections (eg, permission denied).
+          Note that before 1.20, NetworkManager had a bug and this @status value was wrong. It is better to assume success if the method does not return with a D-Bus error. On top of that, you can look at @failures to know whether any of the requested files failed.
         @failures: Paths of connection files that could not be loaded.
 
         Loads or reloads the indicated connections from disk. You should call this
@@ -119,7 +120,7 @@
 
     <!--
         ReloadConnections:
-        @status: Success or failure.
+        @status: This always returns %TRUE.
 
         Tells NetworkManager to reload all connection files from disk, including
         noticing any added or deleted connection files. By default, connections
diff --git a/libnm/nm-client.c b/libnm/nm-client.c
index fd6c35dcae..5189d67a53 100644
--- a/libnm/nm-client.c
+++ b/libnm/nm-client.c
@@ -10,6 +10,7 @@
 
 #include <libudev.h>
 
+#include "nm-glib-aux/nm-dbus-aux.h"
 #include "nm-utils.h"
 #include "nm-manager.h"
 #include "nm-dns-manager.h"
@@ -100,6 +101,7 @@ typedef struct {
 	NMDnsManager *dns_manager;
 	GDBusObjectManager *object_manager;
 	GCancellable *new_object_manager_cancellable;
+	char *name_owner_cached;
 	struct udev *udev;
 	bool udev_inited:1;
 } NMClientPrivate;
@@ -168,6 +170,41 @@ NM_CACHED_QUARK_FCN ("nm-client-error-quark", nm_client_error_quark)
 
 /*****************************************************************************/
 
+GDBusConnection *
+_nm_client_get_dbus_connection (NMClient *client)
+{
+	NMClientPrivate *priv;
+
+	nm_assert (NM_IS_CLIENT (client));
+
+	priv = NM_CLIENT_GET_PRIVATE (client);
+
+	if (!priv->object_manager)
+		return NULL;
+
+	return g_dbus_object_manager_client_get_connection (G_DBUS_OBJECT_MANAGER_CLIENT (priv->object_manager));
+}
+
+const char *
+_nm_client_get_dbus_name_owner (NMClient *client)
+{
+	NMClientPrivate *priv;
+
+	nm_assert (NM_IS_CLIENT (client));
+
+	priv = NM_CLIENT_GET_PRIVATE (client);
+
+	nm_clear_g_free (&priv->name_owner_cached);
+
+	if (!priv->object_manager)
+		return NULL;
+
+	priv->name_owner_cached = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (priv->object_manager));
+	return priv->name_owner_cached;
+}
+
+/*****************************************************************************/
+
 static void
 nm_client_init (NMClient *client)
 {
@@ -176,15 +213,11 @@ nm_client_init (NMClient *client)
 static gboolean
 _nm_client_check_nm_running (NMClient *client, GError **error)
 {
-	if (nm_client_get_nm_running (client))
-		return TRUE;
-	else {
-		g_set_error_literal (error,
-		                     NM_CLIENT_ERROR,
-		                     NM_CLIENT_ERROR_MANAGER_NOT_RUNNING,
-		                     "NetworkManager is not running");
+	if (!nm_client_get_nm_running (client)) {
+		_nm_object_set_error_nm_not_running (error);
 		return FALSE;
 	}
+	return TRUE;
 }
 
 /**
@@ -297,14 +330,22 @@ nm_client_networking_get_enabled (NMClient *client)
 gboolean
 nm_client_networking_set_enabled (NMClient *client, gboolean enable, GError **error)
 {
+	const char *name_owner;
+
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
 
 	/* FIXME(libnm-async-api): add nm_client_networking_set_enabled_async(). */
-	if (!_nm_client_check_nm_running (client, error))
-		return FALSE;
 
-	return nm_manager_networking_set_enabled (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                          enable, error);
+	name_owner = _nm_client_get_dbus_name_owner (client);
+	if (!name_owner) {
+		_nm_object_set_error_nm_not_running (error);
+		return FALSE;
+	}
+
+	return _nm_manager_networking_set_enabled (_nm_client_get_dbus_connection (client),
+	                                           name_owner,
+	                                           enable,
+	                                           error);
 }
 
 /**
@@ -577,20 +618,43 @@ nm_client_connectivity_check_get_uri (NMClient *client)
  * Gets NetworkManager current logging level and domains.
  *
  * Returns: %TRUE on success, %FALSE otherwise
+ *
+ * Deprecated: 1.22, use nm_client_get_logging_async() or GDBusConnection
  **/
 gboolean
-nm_client_get_logging (NMClient *client, char **level, char **domains, GError **error)
+nm_client_get_logging (NMClient *client,
+                       char **level,
+                       char **domains,
+                       GError **error)
 {
+	gs_unref_variant GVariant *ret = NULL;
+
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
 	g_return_val_if_fail (level == NULL || *level == NULL, FALSE);
 	g_return_val_if_fail (domains == NULL || *domains == NULL, FALSE);
 	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
-	if (!_nm_client_check_nm_running (client, error))
+	/* FIXME(libnm-async-api): add nm_client_get_logging_async(). */
+
+	ret = _nm_object_dbus_call_sync (client,
+	                                 NULL,
+	                                 NM_DBUS_PATH,
+	                                 NM_DBUS_INTERFACE,
+	                                 "GetLogging",
+	                                 g_variant_new ("()"),
+	                                 G_VARIANT_TYPE ("(ss)"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret)
 		return FALSE;
 
-	return nm_manager_get_logging (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                               level, domains, error);
+	g_variant_get (ret,
+	               "(ss)",
+	               level,
+	               domains);
+	return TRUE;
 }
 
 /**
@@ -604,6 +668,8 @@ nm_client_get_logging (NMClient *client, char **level, char **domains, GError **
  * Sets NetworkManager logging level and/or domains.
  *
  * Returns: %TRUE on success, %FALSE otherwise
+ *
+ * Deprecated: 1.22, use nm_client_set_logging_async() or GDBusConnection
  **/
 gboolean
 nm_client_set_logging (NMClient *client, const char *level, const char *domains, GError **error)
@@ -611,11 +677,20 @@ nm_client_set_logging (NMClient *client, const char *level, const char *domains,
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
 	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
 
-	if (!_nm_client_check_nm_running (client, error))
-		return FALSE;
+	/* FIXME(libnm-async-api): add nm_client_set_logging_async(). */
 
-	return nm_manager_set_logging (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                               level, domains, error);
+	return _nm_object_dbus_call_sync_void (client,
+	                                       NULL,
+	                                       NM_DBUS_PATH,
+	                                       NM_DBUS_INTERFACE,
+	                                       "SetLogging",
+	                                       g_variant_new ("(ss)",
+	                                                      level ?: "",
+	                                                      domains ?: ""),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -683,33 +758,38 @@ nm_client_check_connectivity (NMClient *client,
                               GCancellable *cancellable,
                               GError **error)
 {
+	gs_unref_variant GVariant *ret = NULL;
+	guint32 connectivity;
+
 	g_return_val_if_fail (NM_IS_CLIENT (client), NM_CONNECTIVITY_UNKNOWN);
 
-	if (!_nm_client_check_nm_running (client, error))
+	ret = _nm_object_dbus_call_sync (client,
+	                                 cancellable,
+	                                 NM_DBUS_PATH,
+	                                 NM_DBUS_INTERFACE,
+	                                 "CheckConnectivity",
+	                                 g_variant_new ("()"),
+	                                 G_VARIANT_TYPE ("(u)"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret)
 		return NM_CONNECTIVITY_UNKNOWN;
 
-	return nm_manager_check_connectivity (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                      cancellable, error);
-}
+	g_variant_get (ret,
+	               "(u)",
+	               &connectivity);
 
-static void
-check_connectivity_cb (GObject *object,
-                       GAsyncResult *result,
-                       gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	NMConnectivityState connectivity;
-	GError *error = NULL;
+	/* upon receiving the synchronous response, we hack the NMClient state
+	 * and update the property outside the ordered D-Bus messages (like
+	 * "PropertiesChanged" signals).
+	 *
+	 * This is really ugly, we shouldn't do this. */
+	_nm_manager_set_connectivity_hack (NM_CLIENT_GET_PRIVATE (client)->manager,
+	                                   connectivity);
 
-	connectivity = nm_manager_check_connectivity_finish (NM_MANAGER (object),
-	                                                     result, &error);
-	if (!error)
-		g_simple_async_result_set_op_res_gssize (simple, connectivity);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return connectivity;
 }
 
 /**
@@ -730,22 +810,22 @@ nm_client_check_connectivity_async (NMClient *client,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_check_connectivity_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_check_connectivity_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                     cancellable, check_connectivity_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_check_connectivity_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "CheckConnectivity",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("(u)"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -764,16 +844,20 @@ nm_client_check_connectivity_finish (NMClient *client,
                                      GAsyncResult *result,
                                      GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *ret = NULL;
+	guint32 connectivity;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), NM_CONNECTIVITY_UNKNOWN);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NM_CONNECTIVITY_UNKNOWN);
+	g_return_val_if_fail (nm_g_task_is_valid (client, result, nm_client_check_connectivity_async), NM_CONNECTIVITY_UNKNOWN);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret)
 		return NM_CONNECTIVITY_UNKNOWN;
-	return (NMConnectivityState) g_simple_async_result_get_op_res_gssize (simple);
+
+	g_variant_get (ret,
+	               "(u)",
+	               &connectivity);
+	return connectivity;
 }
 
 /**
@@ -798,29 +882,18 @@ nm_client_save_hostname (NMClient *client,
                          GError **error)
 {
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
 
-	if (!_nm_client_check_nm_running (client, error))
-		return FALSE;
-
-	return nm_remote_settings_save_hostname (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                         hostname, cancellable, error);
-}
-
-static void
-save_hostname_cb (GObject *object,
-                  GAsyncResult *result,
-                  gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nm_remote_settings_save_hostname_finish (NM_REMOTE_SETTINGS (object), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (client,
+	                                       cancellable,
+	                                       NM_DBUS_PATH_SETTINGS,
+	                                       NM_DBUS_INTERFACE_SETTINGS,
+	                                       "SaveHostname",
+	                                       g_variant_new ("(s)", hostname ?: ""),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -842,23 +915,22 @@ nm_client_save_hostname_async (NMClient *client,
                                GAsyncReadyCallback callback,
                                gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_save_hostname_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_remote_settings_save_hostname_async (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                        hostname,
-	                                        cancellable, save_hostname_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_save_hostname_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH_SETTINGS,
+	                      NM_DBUS_INTERFACE_SETTINGS,
+	                      "SaveHostname",
+	                      g_variant_new ("(s)", hostname ?: ""),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -876,20 +948,14 @@ nm_client_save_hostname_finish (NMClient *client,
                                 GAsyncResult *result,
                                 GError **error)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_save_hostname_async), FALSE);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /*****************************************************************************/
-/* Devices                                                      */
+/* Devices                                                                   */
 /*****************************************************************************/
 
 /**
@@ -1067,22 +1133,32 @@ nm_client_get_activating_connection (NMClient *client)
 }
 
 static void
-activate_cb (GObject *object,
-             GAsyncResult *result,
-             gpointer user_data)
+activate_connection_cb (GObject *object,
+                        GAsyncResult *result,
+                        gpointer user_data)
 {
-	GSimpleAsyncResult *simple = user_data;
-	NMActiveConnection *ac;
+	NMClient *self;
+	gs_unref_object GTask *task = user_data;
+	gs_unref_variant GVariant *ret = NULL;
+	const char *v_active_connection;
 	GError *error = NULL;
 
-	ac = nm_manager_activate_connection_finish (NM_MANAGER (object), result, &error);
-	if (ac)
-		g_simple_async_result_set_op_res_gpointer (simple, ac, g_object_unref);
-	else
-		g_simple_async_result_take_error (simple, error);
+	ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error);
+	if (!ret) {
+		g_dbus_error_strip_remote_error (error);
+		g_task_return_error (task, error);
+		return;
+	}
 
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	self = g_task_get_source_object (task);
+
+	g_variant_get (ret, "(&o)", &v_active_connection);
+
+	nm_manager_wait_for_active_connection (NM_CLIENT_GET_PRIVATE (self)->manager,
+	                                       v_active_connection,
+	                                       NULL,
+	                                       NULL,
+	                                       g_steal_pointer (&task));
 }
 
 /**
@@ -1127,27 +1203,39 @@ nm_client_activate_connection_async (NMClient *client,
                                      GAsyncReadyCallback callback,
                                      gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
+	const char *arg_connection = NULL;
+	const char *arg_device = NULL;
 
 	g_return_if_fail (NM_IS_CLIENT (client));
-	if (device)
-		g_return_if_fail (NM_IS_DEVICE (device));
-	if (connection)
-		g_return_if_fail (NM_IS_CONNECTION (connection));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
+	if (connection) {
+		g_return_if_fail (NM_IS_CONNECTION (connection));
+		arg_connection = nm_connection_get_path (connection);
+		g_return_if_fail (arg_connection);
 	}
 
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_activate_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_activate_connection_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                      connection, device, specific_object,
-	                                      cancellable, activate_cb, simple);
+	if (device) {
+		g_return_if_fail (NM_IS_DEVICE (device));
+		arg_device = nm_object_get_path (NM_OBJECT (device));
+		g_return_if_fail (arg_device);
+	}
+
+	_nm_object_dbus_call (client,
+	                      nm_client_activate_connection_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "ActivateConnection",
+	                      g_variant_new ("(ooo)",
+	                                     arg_connection ?: "/",
+	                                     arg_device ?: "/",
+	                                     specific_object ?: "/"),
+	                      G_VARIANT_TYPE ("(o)"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      activate_connection_cb);
 }
 
 /**
@@ -1166,37 +1254,153 @@ nm_client_activate_connection_finish (NMClient *client,
                                       GAsyncResult *result,
                                       GError **error)
 {
-	GSimpleAsyncResult *simple;
+	nm_auto_free_activate_result _NMActivateResult *r = NULL;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_activate_connection_async), NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	r = g_task_propagate_pointer (G_TASK (result), error);
+	if (!r)
 		return NULL;
-	else
-		return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
+	return g_steal_pointer (&r->active);
 }
 
 static void
-add_activate_cb (GObject *object,
-                 GAsyncResult *result,
-                 gpointer user_data)
+_add_and_activate_connection_done (GObject *object,
+                                   GAsyncResult *result,
+                                   gboolean use_add_and_activate_v2,
+                                   GTask *task_take)
 {
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
-	gs_unref_variant GVariant *result_data = NULL;
-	gs_unref_object NMActiveConnection *ac = NULL;
+	_nm_unused gs_unref_object GTask *task = task_take;
+	NMClient *self;
+	gs_unref_variant GVariant *ret = NULL;
 	GError *error = NULL;
+	const char *v_path;
+	const char *v_active_connection;
+	gs_unref_variant GVariant *v_result = NULL;
 
-	ac = nm_manager_add_and_activate_connection_finish (NM_MANAGER (object), result, &result_data, &error);
-	if (ac) {
-		g_simple_async_result_set_op_res_gpointer (simple,
-		                                           _nm_activate_result_new (ac, result_data),
-		                                           (GDestroyNotify) _nm_activate_result_free);
-	} else
-		g_simple_async_result_take_error (simple, error);
+	ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error);
+	if (!ret) {
+		g_dbus_error_strip_remote_error (error);
+		g_task_return_error (task, error);
+		return;
+	}
 
-	g_simple_async_result_complete (simple);
+	self = g_task_get_source_object (task);
+
+	if (use_add_and_activate_v2) {
+		g_variant_get (ret,
+		               "(&o&o@a{sv})",
+		               &v_path,
+		               &v_active_connection,
+		               &v_result);
+	} else {
+		g_variant_get (ret,
+		               "(&o&o)",
+		               &v_path,
+		               &v_active_connection);
+	}
+
+	nm_manager_wait_for_active_connection (NM_CLIENT_GET_PRIVATE (self)->manager,
+	                                       v_active_connection,
+	                                       v_path,
+	                                       g_steal_pointer (&v_result),
+	                                       g_steal_pointer (&task));
+}
+
+static void
+_add_and_activate_connection_v1_cb (GObject *object, GAsyncResult *result, gpointer user_data)
+{
+	_add_and_activate_connection_done (object, result, FALSE, user_data);
+}
+
+static void
+_add_and_activate_connection_v2_cb (GObject *object, GAsyncResult *result, gpointer user_data)
+{
+	_add_and_activate_connection_done (object, result, TRUE, user_data);
+}
+
+static void
+_add_and_activate_connection (NMClient *client,
+                              gboolean is_v2,
+                              NMConnection *partial,
+                              NMDevice *device,
+                              const char *specific_object,
+                              GVariant *options,
+                              GCancellable *cancellable,
+                              GAsyncReadyCallback callback,
+                              gpointer user_data)
+{
+	GVariant *arg_connection = NULL;
+	gboolean use_add_and_activate_v2 = FALSE;
+	const char *arg_device = NULL;
+	gpointer source_tag;
+
+	g_return_if_fail (NM_IS_CLIENT (client));
+	g_return_if_fail (!partial || NM_IS_CONNECTION (partial));
+
+	if (device) {
+		g_return_if_fail (NM_IS_DEVICE (device));
+		arg_device = nm_object_get_path (NM_OBJECT (device));
+		g_return_if_fail (arg_device);
+	}
+
+	if (partial)
+		arg_connection = nm_connection_to_dbus (partial, NM_CONNECTION_SERIALIZE_ALL);
+	if (!arg_connection)
+		arg_connection = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
+
+	if (is_v2) {
+		if (!options)
+			options = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
+		use_add_and_activate_v2 = TRUE;
+		source_tag = nm_client_add_and_activate_connection2;
+	} else {
+		if (options) {
+			if (g_variant_n_children (options) > 0)
+				use_add_and_activate_v2 = TRUE;
+			else
+				nm_clear_pointer (&options, nm_g_variant_unref_floating);
+		}
+		source_tag = nm_client_add_and_activate_connection_async;
+	}
+
+	if (use_add_and_activate_v2) {
+		_nm_object_dbus_call (client,
+		                      source_tag,
+		                      cancellable,
+		                      callback,
+		                      user_data,
+		                      NM_DBUS_PATH,
+		                      NM_DBUS_INTERFACE,
+		                      "AddAndActivateConnection2",
+		                      g_variant_new ("(@a{sa{sv}}oo@a{sv})",
+		                                     arg_connection,
+		                                     arg_device ?: "/",
+		                                     specific_object ?: "/",
+		                                     options),
+		                      G_VARIANT_TYPE ("(ooa{sv})"),
+		                      G_DBUS_CALL_FLAGS_NONE,
+		                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+		                      _add_and_activate_connection_v2_cb);
+	} else {
+		_nm_object_dbus_call (client,
+		                      source_tag,
+		                      cancellable,
+		                      callback,
+		                      user_data,
+		                      NM_DBUS_PATH,
+		                      NM_DBUS_INTERFACE,
+		                      "AddAndActivateConnection",
+		                      g_variant_new ("(@a{sa{sv}}oo)",
+		                                     arg_connection,
+		                                     arg_device ?: "/",
+		                                     specific_object ?: "/"),
+		                      G_VARIANT_TYPE ("(oo)"),
+		                      G_DBUS_CALL_FLAGS_NONE,
+		                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+		                      _add_and_activate_connection_v1_cb);
+	}
 }
 
 /**
@@ -1213,6 +1417,7 @@ add_activate_cb (GObject *object,
  *   path of a #NMAccessPoint or #NMWimaxNsp owned by @device, which you can
  *   get using nm_object_get_path(), and which will be used to complete the
  *   details of the newly added connection.
+ *   If the variant is floating, it will be consumed.
  * @cancellable: a #GCancellable, or %NULL
  * @callback: callback to be called when the activation has started
  * @user_data: caller-specific data passed to @callback
@@ -1237,32 +1442,15 @@ nm_client_add_and_activate_connection_async (NMClient *client,
                                              GAsyncReadyCallback callback,
                                              gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
-	g_return_if_fail (NM_IS_CLIENT (client));
-	g_return_if_fail (NM_IS_DEVICE (device));
-	if (partial)
-		g_return_if_fail (NM_IS_CONNECTION (partial));
-
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_add_and_activate_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_add_and_activate_connection_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                              partial,
-	                                              device,
-	                                              specific_object,
-	                                              NULL,
-	                                              FALSE,
-	                                              cancellable,
-	                                              add_activate_cb,
-	                                              simple);
+	_add_and_activate_connection (client,
+	                              FALSE,
+	                              partial,
+	                              device,
+	                              specific_object,
+	                              NULL,
+	                              cancellable,
+	                              callback,
+	                              user_data);
 }
 
 /**
@@ -1284,17 +1472,15 @@ nm_client_add_and_activate_connection_finish (NMClient *client,
                                               GAsyncResult *result,
                                               GError **error)
 {
-	GSimpleAsyncResult *simple;
-	_NMActivateResult *r;
+	nm_auto_free_activate_result _NMActivateResult *r = NULL;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_add_and_activate_connection_async), NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	r = g_task_propagate_pointer (G_TASK (result), error);
+	if (!r)
 		return NULL;
-	r = g_simple_async_result_get_op_res_gpointer (simple);
-	return g_object_ref (r->active);
+	return g_steal_pointer (&r->active);
 }
 
 /**
@@ -1350,32 +1536,15 @@ nm_client_add_and_activate_connection2 (NMClient *client,
                                         GAsyncReadyCallback callback,
                                         gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
-	g_return_if_fail (NM_IS_CLIENT (client));
-	g_return_if_fail (NM_IS_DEVICE (device));
-	if (partial)
-		g_return_if_fail (NM_IS_CONNECTION (partial));
-
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_add_and_activate_connection2);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_add_and_activate_connection_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                              partial,
-	                                              device,
-	                                              specific_object,
-	                                              options,
-	                                              TRUE,
-	                                              cancellable,
-	                                              add_activate_cb,
-	                                              simple);
+	_add_and_activate_connection (client,
+	                              TRUE,
+	                              partial,
+	                              device,
+	                              specific_object,
+	                              options,
+	                              cancellable,
+	                              callback,
+	                              user_data);
 }
 
 /**
@@ -1401,20 +1570,18 @@ nm_client_add_and_activate_connection2_finish (NMClient *client,
                                                GVariant **out_result,
                                                GError **error)
 {
-	GSimpleAsyncResult *simple;
-	_NMActivateResult *r;
+	nm_auto_free_activate_result _NMActivateResult *r = NULL;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_add_and_activate_connection2), NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error)) {
+	r = g_task_propagate_pointer (G_TASK (result), error);
+	if (!r) {
 		NM_SET_OUT (out_result, NULL);
 		return NULL;
 	}
-	r = g_simple_async_result_get_op_res_gpointer (simple);
-	NM_SET_OUT (out_result, nm_g_variant_ref (r->add_and_activate_output));
-	return g_object_ref (r->active);
+	NM_SET_OUT (out_result, g_steal_pointer (&r->add_and_activate_output));
+	return g_steal_pointer (&r->active);
 }
 
 /**
@@ -1436,30 +1603,24 @@ nm_client_deactivate_connection (NMClient *client,
                                  GCancellable *cancellable,
                                  GError **error)
 {
+	const char *active_path;
+
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
 	g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (active), FALSE);
 
-	if (!nm_client_get_nm_running (client))
-		return TRUE;
+	active_path = nm_object_get_path (NM_OBJECT (active));
+	g_return_val_if_fail (active_path, FALSE);
 
-	return nm_manager_deactivate_connection (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                         active, cancellable, error);
-}
-
-static void
-deactivated_cb (GObject *object,
-                GAsyncResult *result,
-                gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nm_manager_deactivate_connection_finish (NM_MANAGER (object), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else
-		g_simple_async_result_take_error (simple, error);
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (client,
+	                                       cancellable,
+	                                       NM_DBUS_PATH,
+	                                       NM_DBUS_INTERFACE,
+	                                       "DeactivateConnection",
+	                                       g_variant_new ("(o)", active_path),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -1479,26 +1640,27 @@ nm_client_deactivate_connection_async (NMClient *client,
                                        GAsyncReadyCallback callback,
                                        gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
+	const char *active_path;
 
 	g_return_if_fail (NM_IS_CLIENT (client));
 	g_return_if_fail (NM_IS_ACTIVE_CONNECTION (active));
 
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_deactivate_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
+	active_path = nm_object_get_path (NM_OBJECT (active));
+	g_return_if_fail (active_path);
 
-	if (!_nm_client_check_nm_running (client, NULL)) {
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-		g_simple_async_result_complete_in_idle (simple);
-		g_object_unref (simple);
-		return;
-	}
-
-	nm_manager_deactivate_connection_async (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                        active,
-	                                        cancellable, deactivated_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_deactivate_connection_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "DeactivateConnection",
+	                      g_variant_new ("(o)", active_path),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -1516,16 +1678,10 @@ nm_client_deactivate_connection_finish (NMClient *client,
                                         GAsyncResult *result,
                                         GError **error)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_deactivate_connection_async), FALSE);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /*****************************************************************************/
@@ -1629,55 +1785,160 @@ nm_client_get_connection_by_uuid (NMClient *client, const char *uuid)
 	return nm_remote_settings_get_connection_by_uuid (NM_CLIENT_GET_PRIVATE (client)->settings, uuid);
 }
 
-typedef struct {
-	NMRemoteConnection *connection;
-	GVariant *results;
-} AddConnection2CbData;
-
 static void
-add_connection2_cb_data_destroy (gpointer user_data)
+_add_connection_cb (GObject *source,
+                    GAsyncResult *result,
+                    gboolean with_extra_arg,
+                    gpointer user_data)
 {
-	AddConnection2CbData *data = user_data;
+	NMClient *self;
+	gs_unref_variant GVariant *ret = NULL;
+	gs_unref_object GTask *task = user_data;
+	gs_unref_variant GVariant *v_result = NULL;
+	const char *v_path;
+	GError *error = NULL;
 
-	g_object_unref (data->connection);
-	nm_g_variant_unref (data->results);
-	nm_g_slice_free (data);
+	ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
+	if (!ret) {
+		g_dbus_error_strip_remote_error (error);
+		g_task_return_error (task, error);
+		return;
+	}
+
+	if (with_extra_arg) {
+		g_variant_get (ret,
+		               "(&o@a{sv})",
+		               &v_path,
+		               &v_result);
+	} else {
+		g_variant_get (ret,
+		               "(&o)",
+		               &v_path);
+	}
+
+	self = g_task_get_source_object (task);
+
+	nm_remote_settings_wait_for_connection (NM_CLIENT_GET_PRIVATE (self)->settings,
+	                                        v_path,
+	                                        g_steal_pointer (&v_result),
+	                                        g_steal_pointer (&task));
 }
 
 static void
-add_connection2_cb (NMRemoteSettings *self,
-                    NMRemoteConnection *connection,
-                    GVariant *results,
-                    GError *error,
-                    gpointer user_data)
+_add_connection_cb_without_extra_result (GObject *object, GAsyncResult *result, gpointer user_data)
 {
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
+	_add_connection_cb (object, result, FALSE, user_data);
+}
 
-	if (error) {
-		g_simple_async_result_take_error (simple,
-		                                  g_error_new_literal (error->domain,
-		                                                       error->code,
-		                                                       error->message));
-	} else if (g_simple_async_result_get_source_tag (simple) == nm_client_add_connection_async) {
-		g_simple_async_result_set_op_res_gpointer (simple,
-		                                           g_object_ref (connection),
-		                                           g_object_unref);
+static void
+_add_connection_cb_with_extra_result (GObject *object, GAsyncResult *result, gpointer user_data)
+{
+	_add_connection_cb (object, result, TRUE, user_data);
+}
+
+static void
+_add_connection_call (NMClient *self,
+                      gpointer source_tag,
+                      gboolean ignore_out_result,
+                      GVariant *settings,
+                      NMSettingsAddConnection2Flags flags,
+                      GVariant *args,
+                      GCancellable *cancellable,
+                      GAsyncReadyCallback callback,
+                      gpointer user_data)
+{
+	g_return_if_fail (NM_IS_CLIENT (self));
+	g_return_if_fail (!settings || g_variant_is_of_type (settings, G_VARIANT_TYPE ("a{sa{sv}}")));
+	g_return_if_fail (!args || g_variant_is_of_type (args, G_VARIANT_TYPE ("a{sv}")));
+
+	if (!settings)
+		settings = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
+
+	/* Although AddConnection2() being capable to handle also AddConnection() and
+	 * AddConnectionUnsaved() variants, we prefer to use the old D-Bus methods when
+	 * they are sufficient. The reason is that libnm should avoid hard dependencies
+	 * on 1.20 API whenever possible. */
+	if (    ignore_out_result
+	     && flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK) {
+		_nm_object_dbus_call (self,
+		                      source_tag,
+		                      cancellable,
+		                      callback,
+		                      user_data,
+		                      NM_DBUS_PATH_SETTINGS,
+		                      NM_DBUS_INTERFACE_SETTINGS,
+		                      "AddConnection",
+		                      g_variant_new ("(@a{sa{sv}})", settings),
+		                      G_VARIANT_TYPE ("(o)"),
+		                      G_DBUS_CALL_FLAGS_NONE,
+		                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+		                      _add_connection_cb_without_extra_result);
+	} else if (   ignore_out_result
+	           && flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY) {
+		_nm_object_dbus_call (self,
+		                      source_tag,
+		                      cancellable,
+		                      callback,
+		                      user_data,
+		                      NM_DBUS_PATH_SETTINGS,
+		                      NM_DBUS_INTERFACE_SETTINGS,
+		                      "AddConnectionUnsaved",
+		                      g_variant_new ("(@a{sa{sv}})", settings),
+		                      G_VARIANT_TYPE ("(o)"),
+		                      G_DBUS_CALL_FLAGS_NONE,
+		                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+		                      _add_connection_cb_without_extra_result);
 	} else {
-		AddConnection2CbData *data;
+		_nm_object_dbus_call (self,
+		                      source_tag,
+		                      cancellable,
+		                      callback,
+		                      user_data,
+		                      NM_DBUS_PATH_SETTINGS,
+		                      NM_DBUS_INTERFACE_SETTINGS,
+		                      "AddConnection2",
+		                      g_variant_new ("(@a{sa{sv}}u@a{sv})",
+		                                     settings,
+		                                     (guint32) flags,
+		                                        args
+		                                     ?: g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0)),
+		                      G_VARIANT_TYPE ("(oa{sv})"),
+		                      G_DBUS_CALL_FLAGS_NONE,
+		                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+		                      _add_connection_cb_with_extra_result);
+	}
+}
 
-		nm_assert (g_simple_async_result_get_source_tag (simple) == nm_client_add_connection2);
+static NMRemoteConnection *
+_add_connection_call_finish (NMClient *client,
+                             GAsyncResult *result,
+                             gpointer source_tag,
+                             GVariant **out_result,
+                             GError **error)
+{
+	nm_auto_free_add_connection_result_data NMAddConnectionResultData *result_data = NULL;
 
-		data = g_slice_new (AddConnection2CbData);
-		*data = (AddConnection2CbData) {
-			.connection = g_object_ref (connection),
-			.results    = nm_g_variant_ref (results),
-		};
-		g_simple_async_result_set_op_res_gpointer (simple,
-		                                           data,
-		                                           add_connection2_cb_data_destroy);
+	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, source_tag), NULL);
+
+	result_data = g_task_propagate_pointer (G_TASK (result), error);
+	if (!result_data) {
+		NM_SET_OUT (out_result, NULL);
+		return NULL;
 	}
 
-	g_simple_async_result_complete (simple);
+	nm_assert (NM_IS_REMOTE_CONNECTION (result_data->connection));
+
+	NM_SET_OUT (out_result, g_steal_pointer (&result_data->extra_results));
+	return g_steal_pointer (&result_data->connection);
+}
+
+void
+nm_add_connection_result_data_free (NMAddConnectionResultData *result_data)
+{
+	nm_g_object_unref (result_data->connection);
+	nm_g_variant_unref (result_data->extra_results);
+	nm_g_slice_free (result_data);
 }
 
 /**
@@ -1713,32 +1974,19 @@ nm_client_add_connection_async (NMClient *client,
                                 GAsyncReadyCallback callback,
                                 gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
-	g_return_if_fail (NM_IS_CLIENT (client));
 	g_return_if_fail (NM_IS_CONNECTION (connection));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_add_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nm_remote_settings_add_connection2 (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                    nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL),
-	                                    save_to_disk
-	                                    ? NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK
-	                                    : NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY,
-	                                    NULL,
-	                                    TRUE,
-	                                    cancellable,
-	                                    add_connection2_cb,
-	                                    simple);
+	_add_connection_call (client,
+	                      nm_client_add_connection_async,
+	                      TRUE,
+	                      nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL),
+	                        save_to_disk
+	                      ? NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK
+	                      : NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY,
+	                      NULL,
+	                      cancellable,
+	                      callback,
+	                      user_data);
 }
 
 /**
@@ -1757,15 +2005,11 @@ nm_client_add_connection_finish (NMClient *client,
                                  GAsyncResult *result,
                                  GError **error)
 {
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (client), nm_client_add_connection_async), NULL);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NULL;
-	return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
+	return _add_connection_call_finish (client,
+	                                    result,
+	                                    nm_client_add_connection_async,
+	                                    NULL,
+	                                    error);
 }
 
 /**
@@ -1800,33 +2044,15 @@ nm_client_add_connection2 (NMClient *client,
                            GAsyncReadyCallback callback,
                            gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
-	g_return_if_fail (NM_IS_CLIENT (client));
-	g_return_if_fail (g_variant_is_of_type (settings, G_VARIANT_TYPE ("a{sa{sv}}")));
-	g_return_if_fail (!args || g_variant_is_of_type (args, G_VARIANT_TYPE ("a{sv}")));
-
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client),
-	                                    callback,
-	                                    user_data,
-	                                    nm_client_add_connection2);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nm_remote_settings_add_connection2 (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                    settings,
-	                                    flags,
-	                                    args,
-	                                    ignore_out_result,
-	                                    cancellable,
-	                                    add_connection2_cb,
-	                                    simple);
+	_add_connection_call (client,
+	                      nm_client_add_connection2,
+	                      ignore_out_result,
+	                      settings,
+	                      flags,
+	                      args,
+	                      cancellable,
+	                      callback,
+	                      user_data);
 }
 
 /**
@@ -1850,21 +2076,11 @@ nm_client_add_connection2_finish (NMClient *client,
                                   GVariant **out_result,
                                   GError **error)
 {
-	GSimpleAsyncResult *simple;
-	AddConnection2CbData *data;
-
-	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (client), nm_client_add_connection2), NULL);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error)) {
-		NM_SET_OUT (out_result, NULL);
-		return NULL;
-	}
-
-	data = g_simple_async_result_get_op_res_gpointer (simple);
-	NM_SET_OUT (out_result, g_variant_ref (data->results));
-	return g_object_ref (data->connection);
+	return _add_connection_call_finish (client,
+	                                    result,
+	                                    nm_client_add_connection2,
+	                                    out_result,
+	                                    error);
 }
 
 /**
@@ -1888,8 +2104,16 @@ nm_client_add_connection2_finish (NMClient *client,
  * then @failures will be set to a %NULL-terminated array of the
  * filenames that failed to load.
  *
- * Returns: %TRUE if NetworkManager at least tried to load @filenames,
- * %FALSE if an error occurred (eg, permission denied).
+ * Returns: %TRUE on success.
+ *
+ * Warning: before libnm 1.22, the boolean return value was inconsistent.
+ *   That is made worse, because when running against certain server versions
+ *   before 1.20, the server would return wrong values for success/failure.
+ *   This means, if you use this function in libnm before 1.22, you are advised
+ *   to ignore the boolean return value and only look at @failures and @error.
+ *   With libnm >= 1.22, the boolean return value corresponds to whether @error was
+ *   set. Note that even in the success case, you might have individual @failures.
+ *   With 1.22, the return value is consistent with nm_client_load_connections_finish().
  *
  * Deprecated: 1.22, use nm_client_load_connections_async() or GDBusConnection
  **/
@@ -1900,32 +2124,34 @@ nm_client_load_connections (NMClient *client,
                             GCancellable *cancellable,
                             GError **error)
 {
+	gs_unref_variant GVariant *ret = NULL;
+
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (filenames != NULL, FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
 
-	if (!_nm_client_check_nm_running (client, error))
+	ret = _nm_object_dbus_call_sync (client,
+	                                 cancellable,
+	                                 NM_DBUS_PATH_SETTINGS,
+	                                 NM_DBUS_INTERFACE_SETTINGS,
+	                                 "LoadConnections",
+	                                 g_variant_new ("(^as)",
+	                                                filenames ?: NM_PTRARRAY_EMPTY (char *)),
+	                                 G_VARIANT_TYPE ("(bas)"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret) {
+		*failures = NULL;
 		return FALSE;
+	}
 
-	return nm_remote_settings_load_connections (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                            filenames, failures,
-	                                            cancellable, error);
-}
+	g_variant_get (ret,
+	               "(b^as)",
+	               NULL,
+	               &failures);
 
-static void
-load_connections_cb (GObject *object, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-	char **failures = NULL;
-
-	if (nm_remote_settings_load_connections_finish (NM_REMOTE_SETTINGS (object),
-	                                                &failures, result, &error))
-		g_simple_async_result_set_op_res_gpointer (simple, failures, (GDestroyNotify) g_strfreev);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return TRUE;
 }
 
 /**
@@ -1948,24 +2174,23 @@ nm_client_load_connections_async (NMClient *client,
                                   GAsyncReadyCallback callback,
                                   gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
-	g_return_if_fail (filenames != NULL);
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_load_connections_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_remote_settings_load_connections_async (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                           filenames,
-	                                           cancellable, load_connections_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_load_connections_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH_SETTINGS,
+	                      NM_DBUS_INTERFACE_SETTINGS,
+	                      "LoadConnections",
+	                      g_variant_new ("(^as)",
+	                                     filenames ?: NM_PTRARRAY_EMPTY (char *)),
+	                      G_VARIANT_TYPE ("(bas)"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -1980,8 +2205,8 @@ nm_client_load_connections_async (NMClient *client,
 
  * See nm_client_load_connections() for more details.
  *
- * Returns: %TRUE if NetworkManager at least tried to load @filenames,
- * %FALSE if an error occurred (eg, permission denied).
+ * Returns: %TRUE on success.
+ *   Note that even in the success case, you might have individual @failures.
  **/
 gboolean
 nm_client_load_connections_finish (NMClient *client,
@@ -1989,19 +2214,23 @@ nm_client_load_connections_finish (NMClient *client,
                                    GAsyncResult *result,
                                    GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *ret = NULL;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_load_connections_async), FALSE);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret) {
+		*failures = NULL;
 		return FALSE;
-	else {
-		if (failures)
-			*failures = g_strdupv (g_simple_async_result_get_op_res_gpointer (simple));
-		return TRUE;
 	}
+
+	g_variant_get (ret,
+	               "(b^as)",
+	               NULL,
+	               &failures);
+
+	return TRUE;
 }
 
 /**
@@ -2023,29 +2252,26 @@ nm_client_reload_connections (NMClient *client,
                               GCancellable *cancellable,
                               GError **error)
 {
-	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
+	gs_unref_variant GVariant *ret = NULL;
 
-	if (!_nm_client_check_nm_running (client, error))
+	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
+
+	ret = _nm_object_dbus_call_sync (client,
+	                                 cancellable,
+	                                 NM_DBUS_PATH_SETTINGS,
+	                                 NM_DBUS_INTERFACE_SETTINGS,
+	                                 "ReloadConnections",
+	                                 g_variant_new ("()"),
+	                                 G_VARIANT_TYPE ("(b)"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret)
 		return FALSE;
 
-	return nm_remote_settings_reload_connections (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                              cancellable, error);
-}
-
-static void
-reload_connections_cb (GObject *object, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nm_remote_settings_reload_connections_finish (NM_REMOTE_SETTINGS (object),
-	                                                  result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return TRUE;
 }
 
 /**
@@ -2065,22 +2291,22 @@ nm_client_reload_connections_async (NMClient *client,
                                     GAsyncReadyCallback callback,
                                     gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_reload_connections_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_remote_settings_reload_connections_async (NM_CLIENT_GET_PRIVATE (client)->settings,
-	                                             cancellable, reload_connections_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_reload_connections_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH_SETTINGS,
+	                      NM_DBUS_INTERFACE_SETTINGS,
+	                      "ReloadConnections",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("(b)"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -2098,16 +2324,16 @@ nm_client_reload_connections_finish (NMClient *client,
                                      GAsyncResult *result,
                                      GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *ret = NULL;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_reload_connections_async), FALSE);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret)
 		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+
+	return TRUE;
 }
 
 /*****************************************************************************/
@@ -2374,25 +2600,6 @@ dns_notify (GObject *object,
 	}
 }
 
-static void
-checkpoint_create_cb (GObject *object,
-                      GAsyncResult *result,
-                      gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	NMCheckpoint *checkpoint;
-	GError *error = NULL;
-
-	checkpoint = nm_manager_checkpoint_create_finish (NM_MANAGER (object), result, &error);
-	if (checkpoint)
-		g_simple_async_result_set_op_res_gpointer (simple, checkpoint, g_object_unref);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
 /**
  * nm_client_get_checkpoints:
  * @client: a #NMClient
@@ -2416,6 +2623,35 @@ nm_client_get_checkpoints (NMClient *client)
 	return nm_manager_get_checkpoints (NM_CLIENT_GET_PRIVATE (client)->manager);
 }
 
+static void
+checkpoint_create_cb (GObject *object,
+                      GAsyncResult *result,
+                      gpointer user_data)
+{
+	NMClient *self;
+	gs_unref_object GTask *task = user_data;
+	gs_unref_variant GVariant *ret = NULL;
+	const char *checkpoint_path;
+	GError *error = NULL;
+
+	ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error);
+	if (!ret) {
+		g_dbus_error_strip_remote_error (error);
+		g_task_return_error (task, error);
+		return;
+	}
+
+	g_variant_get (ret,
+	               "(&o)",
+	               &checkpoint_path);
+
+	self = g_task_get_source_object (task);
+
+	nm_manager_wait_for_checkpoint (NM_CLIENT_GET_PRIVATE (self)->manager,
+	                                checkpoint_path,
+	                                g_steal_pointer (&task));
+}
+
 /**
  * nm_client_checkpoint_create:
  * @client: the %NMClient
@@ -2443,23 +2679,35 @@ nm_client_checkpoint_create (NMClient *client,
                              GAsyncReadyCallback callback,
                              gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
+	gs_free const char **paths = NULL;
+	guint i;
 
 	g_return_if_fail (NM_IS_CLIENT (client));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
+	if (   devices
+	    && devices->len > 0) {
+		paths = g_new (const char *, devices->len + 1);
+		for (i = 0; i < devices->len; i++)
+			paths[i] = nm_object_get_path (NM_OBJECT (devices->pdata[i]));
+		paths[i] = NULL;
 	}
 
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_checkpoint_create);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_create (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                              devices, rollback_timeout, flags,
-	                              cancellable, checkpoint_create_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_checkpoint_create,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "CheckpointCreate",
+	                      g_variant_new ("(^aouu)",
+	                                     paths ?: NM_PTRARRAY_EMPTY (const char *),
+	                                     rollback_timeout,
+	                                     flags),
+	                      G_VARIANT_TYPE ("(o)"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      checkpoint_create_cb);
 }
 
 /**
@@ -2480,33 +2728,10 @@ nm_client_checkpoint_create_finish (NMClient *client,
                                     GAsyncResult *result,
                                     GError **error)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_checkpoint_create), NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NULL;
-	else
-		return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
-}
-
-static void
-checkpoint_destroy_cb (GObject *object,
-                       GAsyncResult *result,
-                       gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nm_manager_checkpoint_destroy_finish (NM_MANAGER (object), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return g_task_propagate_pointer (G_TASK (result), error);
 }
 
 /**
@@ -2528,24 +2753,22 @@ nm_client_checkpoint_destroy (NMClient *client,
                               GAsyncReadyCallback callback,
                               gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
 	g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_checkpoint_destroy);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_destroy (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                               checkpoint_path,
-	                               cancellable, checkpoint_destroy_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_checkpoint_destroy,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "CheckpointDestroy",
+	                      g_variant_new ("(o)", checkpoint_path),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -2566,35 +2789,10 @@ nm_client_checkpoint_destroy_finish (NMClient *client,
                                      GAsyncResult *result,
                                      GError **error)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_checkpoint_destroy), FALSE);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
-}
-
-static void
-checkpoint_rollback_cb (GObject *object,
-                        GAsyncResult *result,
-                        gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GHashTable *hash;
-	GError *error = NULL;
-
-	hash = nm_manager_checkpoint_rollback_finish (NM_MANAGER (object), result, &error);
-	if (hash)
-		g_simple_async_result_set_op_res_gpointer (simple, hash, (GDestroyNotify) g_hash_table_unref);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /**
@@ -2616,24 +2814,22 @@ nm_client_checkpoint_rollback (NMClient *client,
                                GAsyncReadyCallback callback,
                                gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
 	g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_checkpoint_rollback);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_rollback (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                checkpoint_path,
-	                                cancellable, checkpoint_rollback_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_checkpoint_rollback,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "CheckpointRollback",
+	                      g_variant_new ("(o)", checkpoint_path),
+	                      G_VARIANT_TYPE ("(a{su})"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -2655,35 +2851,31 @@ nm_client_checkpoint_rollback_finish (NMClient *client,
                                       GAsyncResult *result,
                                       GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *ret = NULL;
+	gs_unref_variant GVariant *v_result = NULL;
+	GVariantIter iter;
 	GHashTable *hash;
+	const char *path;
+	guint32 r;
 
 	g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_checkpoint_rollback), NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret)
 		return NULL;
-	else {
-		hash = g_simple_async_result_get_op_res_gpointer (simple);
-		return g_hash_table_ref (hash);
-	}
-}
 
-static void
-checkpoint_adjust_rollback_timeout_cb (GObject *object,
-                                       GAsyncResult *result,
-                                       gpointer user_data)
-{
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
+	g_variant_get (ret,
+	               "(@a{su})",
+	               &v_result);
 
-	if (nm_manager_checkpoint_adjust_rollback_timeout_finish (NM_MANAGER (object), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else
-		g_simple_async_result_take_error (simple, error);
+	hash = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, NULL);
 
-	g_simple_async_result_complete (simple);
+	g_variant_iter_init (&iter, v_result);
+	while (g_variant_iter_next (&iter, "{&su}", &path, &r))
+		g_hash_table_insert (hash, g_strdup (path), GUINT_TO_POINTER (r));
+
+	return hash;
 }
 
 /**
@@ -2709,24 +2901,24 @@ nm_client_checkpoint_adjust_rollback_timeout (NMClient *client,
                                               GAsyncReadyCallback callback,
                                               gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
 	g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_checkpoint_rollback);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_checkpoint_adjust_rollback_timeout (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                                               checkpoint_path, add_timeout,
-	                                               cancellable, checkpoint_adjust_rollback_timeout_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_checkpoint_adjust_rollback_timeout,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "CheckpointAdjustRollbackTimeout",
+	                      g_variant_new ("(ou)",
+	                                     checkpoint_path,
+	                                     add_timeout),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -2747,26 +2939,9 @@ nm_client_checkpoint_adjust_rollback_timeout_finish (NMClient *client,
                                                      GError **error)
 {
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_checkpoint_adjust_rollback_timeout), FALSE);
 
-	return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-	                                               error);
-}
-
-static void
-reload_cb (GObject *object,
-           GAsyncResult *result,
-           gpointer user_data)
-{
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nm_manager_reload_finish (NM_MANAGER (object), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else
-		g_simple_async_result_take_error (simple, error);
-
-	g_simple_async_result_complete (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /**
@@ -2792,23 +2967,21 @@ nm_client_reload (NMClient *client,
                   GAsyncReadyCallback callback,
                   gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-	GError *error = NULL;
-
 	g_return_if_fail (NM_IS_CLIENT (client));
 
-	if (!_nm_client_check_nm_running (client, &error)) {
-		g_simple_async_report_take_gerror_in_idle (G_OBJECT (client), callback, user_data, error);
-		return;
-	}
-
-	simple = g_simple_async_result_new (G_OBJECT (client), callback, user_data,
-	                                    nm_client_reload);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nm_manager_reload (NM_CLIENT_GET_PRIVATE (client)->manager,
-	                   flags,
-	                   cancellable, reload_cb, simple);
+	_nm_object_dbus_call (client,
+	                      nm_client_reload,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "Reload",
+	                      g_variant_new ("(u)", (guint32) flags),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -2829,10 +3002,9 @@ nm_client_reload_finish (NMClient *client,
                          GError **error)
 {
 	g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, client, nm_client_reload), FALSE);
 
-	return !g_simple_async_result_propagate_error (G_SIMPLE_ASYNC_RESULT (result),
-	                                               error);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /****************************************************************/
@@ -3454,6 +3626,8 @@ dispose (GObject *object)
 		udev_unref (priv->udev);
 		priv->udev = NULL;
 	}
+
+	nm_clear_g_free (&priv->name_owner_cached);
 }
 
 static void
diff --git a/libnm/nm-client.h b/libnm/nm-client.h
index 0b3b0e36e7..32cbd168a0 100644
--- a/libnm/nm-client.h
+++ b/libnm/nm-client.h
@@ -277,10 +277,13 @@ void     nm_client_connectivity_check_set_enabled (NMClient *client,
 NM_AVAILABLE_IN_1_20
 const char *nm_client_connectivity_check_get_uri (NMClient *client);
 
+_NM_DEPRECATED_SYNC_METHOD
 gboolean nm_client_get_logging (NMClient *client,
                                 char **level,
                                 char **domains,
                                 GError **error);
+
+_NM_DEPRECATED_SYNC_METHOD
 gboolean nm_client_set_logging (NMClient *client,
                                 const char *level,
                                 const char *domains,
diff --git a/libnm/nm-dbus-helpers.h b/libnm/nm-dbus-helpers.h
index 8f823f0e87..5a0fb756ab 100644
--- a/libnm/nm-dbus-helpers.h
+++ b/libnm/nm-dbus-helpers.h
@@ -12,6 +12,8 @@
 
 #include "nm-std-aux/nm-dbus-compat.h"
 
+#define NM_DBUS_DEFAULT_TIMEOUT_MSEC   25000
+
 GBusType _nm_dbus_bus_type (void);
 
 void             _nm_dbus_proxy_replace_match   (GDBusProxy *proxy);
diff --git a/libnm/nm-device-wifi-p2p.c b/libnm/nm-device-wifi-p2p.c
index e107721190..0aaf3ecc26 100644
--- a/libnm/nm-device-wifi-p2p.c
+++ b/libnm/nm-device-wifi-p2p.c
@@ -7,6 +7,7 @@
 
 #include "nm-device-wifi-p2p.h"
 
+#include "nm-glib-aux/nm-dbus-aux.h"
 #include "nm-setting-connection.h"
 #include "nm-setting-wifi-p2p.h"
 #include "nm-utils.h"
@@ -19,11 +20,6 @@
 
 /*****************************************************************************/
 
-typedef struct {
-	NMDeviceWifiP2P *device;
-	GSimpleAsyncResult *simple;
-} RequestScanInfo;
-
 NM_GOBJECT_PROPERTIES_DEFINE_BASE (
 	PROP_HW_ADDRESS,
 	PROP_PEERS,
@@ -142,23 +138,6 @@ nm_device_wifi_p2p_get_peer_by_path (NMDeviceWifiP2P *device,
 	return peer;
 }
 
-static void
-start_find_finished_cb (GObject      *obj,
-                        GAsyncResult *res,
-                        gpointer user_data)
-{
-	NMDBusDeviceWifiP2P *proxy = (NMDBusDeviceWifiP2P*) obj;
-	gs_unref_object GTask *task = G_TASK (user_data);
-	GError *error = NULL;
-	gboolean success;
-
-	success = nmdbus_device_wifi_p2p_call_start_find_finish (proxy, res, &error);
-	if (!success)
-		g_task_return_error (task, error);
-	else
-		g_task_return_boolean (task, TRUE);
-}
-
 /**
  * nm_device_wifi_p2p_start_find:
  * @device: a #NMDeviceWifiP2P
@@ -177,26 +156,32 @@ start_find_finished_cb (GObject      *obj,
  * Since: 1.16
  **/
 void
-nm_device_wifi_p2p_start_find (NMDeviceWifiP2P     *device,
-                               GVariant            *options,
-                               GCancellable        *cancellable,
-                               GAsyncReadyCallback  callback,
-                               gpointer             user_data)
+nm_device_wifi_p2p_start_find (NMDeviceWifiP2P *device,
+                               GVariant *options,
+                               GCancellable *cancellable,
+                               GAsyncReadyCallback callback,
+                               gpointer user_data)
 {
-	NMDeviceWifiP2PPrivate *priv = NM_DEVICE_WIFI_P2P_GET_PRIVATE (device);
-	GTask *task;
-
 	g_return_if_fail (NM_IS_DEVICE_WIFI_P2P (device));
-
-	task = g_task_new (device, cancellable, callback, user_data);
+	g_return_if_fail (!options || g_variant_is_of_type (options, G_VARIANT_TYPE_VARDICT));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
 	if (!options)
 		options = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
-	nmdbus_device_wifi_p2p_call_start_find (priv->proxy,
-	                                        options,
-	                                        cancellable,
-	                                        start_find_finished_cb,
-	                                        task);
+
+	_nm_object_dbus_call (device,
+	                      nm_device_wifi_p2p_start_find,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "StartFind",
+	                      g_variant_new ("(@a{sv})", options),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_cb);
 }
 
 /**
@@ -216,26 +201,12 @@ nm_device_wifi_p2p_start_find_finish (NMDeviceWifiP2P  *device,
                                       GAsyncResult     *result,
                                       GError          **error)
 {
+	g_return_val_if_fail (NM_IS_DEVICE_WIFI_P2P (device), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_wifi_p2p_start_find), FALSE);
+
 	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
-static void
-stop_find_finished_cb (GObject      *obj,
-                       GAsyncResult *res,
-                       gpointer user_data)
-{
-	NMDBusDeviceWifiP2P *proxy = (NMDBusDeviceWifiP2P*) obj;
-	gs_unref_object GTask *task = G_TASK (user_data);
-	GError *error = NULL;
-	gboolean success;
-
-	success = nmdbus_device_wifi_p2p_call_stop_find_finish (proxy, res, &error);
-	if (!success)
-		g_task_return_error (task, error);
-	else
-		g_task_return_boolean (task, TRUE);
-}
-
 /**
  * nm_device_wifi_p2p_stop_find:
  * @device: a #NMDeviceWifiP2P
@@ -253,17 +224,22 @@ nm_device_wifi_p2p_stop_find (NMDeviceWifiP2P     *device,
                               GAsyncReadyCallback  callback,
                               gpointer             user_data)
 {
-	NMDeviceWifiP2PPrivate *priv = NM_DEVICE_WIFI_P2P_GET_PRIVATE (device);
-	GTask *task;
-
 	g_return_if_fail (NM_IS_DEVICE_WIFI_P2P (device));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	task = g_task_new (device, cancellable, callback, user_data);
-
-	nmdbus_device_wifi_p2p_call_stop_find (priv->proxy,
-	                                       cancellable,
-	                                       stop_find_finished_cb,
-	                                       task);
+	_nm_object_dbus_call (device,
+	                      nm_device_wifi_p2p_stop_find,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      NM_DBUS_PATH,
+	                      NM_DBUS_INTERFACE,
+	                      "StopFind",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_cb);
 }
 
 /**
@@ -283,6 +259,9 @@ nm_device_wifi_p2p_stop_find_finish (NMDeviceWifiP2P  *device,
                                       GAsyncResult     *result,
                                       GError          **error)
 {
+	g_return_val_if_fail (NM_IS_DEVICE_WIFI_P2P (device), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_wifi_p2p_stop_find), FALSE);
+
 	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
diff --git a/libnm/nm-device-wifi.c b/libnm/nm-device-wifi.c
index 30dbd09f89..a2920e8156 100644
--- a/libnm/nm-device-wifi.c
+++ b/libnm/nm-device-wifi.c
@@ -8,6 +8,7 @@
 
 #include "nm-device-wifi.h"
 
+#include "nm-glib-aux/nm-dbus-aux.h"
 #include "nm-setting-connection.h"
 #include "nm-setting-wireless.h"
 #include "nm-setting-wireless-security.h"
@@ -26,11 +27,6 @@ G_DEFINE_TYPE (NMDeviceWifi, nm_device_wifi, NM_TYPE_DEVICE)
 void _nm_device_wifi_set_wireless_enabled (NMDeviceWifi *device, gboolean enabled);
 static void state_changed_cb (NMDevice *device, GParamSpec *pspec, gpointer user_data);
 
-typedef struct {
-	NMDeviceWifi *device;
-	GSimpleAsyncResult *simple;
-} RequestScanInfo;
-
 typedef struct {
 	NMDBusDeviceWifi *proxy;
 
@@ -42,8 +38,6 @@ typedef struct {
 	NMDeviceWifiCapabilities wireless_caps;
 	GPtrArray *aps;
 	gint64 last_scan;
-
-	RequestScanInfo *scan_info;
 } NMDeviceWifiPrivate;
 
 enum {
@@ -273,52 +267,6 @@ nm_device_wifi_get_last_scan (NMDeviceWifi *device)
 	return NM_DEVICE_WIFI_GET_PRIVATE (device)->last_scan;
 }
 
-static GVariant *
-prepare_scan_options (GVariant *options)
-{
-
-	GVariant *variant;
-	GVariantIter iter;
-	GVariantBuilder builder;
-	char *key;
-	GVariant *value;
-
-	if (!options)
-		variant = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
-	else {
-		g_variant_builder_init (&builder, G_VARIANT_TYPE_VARDICT);
-		g_variant_iter_init (&iter, options);
-		while (g_variant_iter_loop (&iter, "{sv}", &key, &value))
-		{
-			// FIXME: verify options here?
-			g_variant_builder_add (&builder, "{sv}", key, value);
-		}
-		variant = g_variant_builder_end (&builder);
-	}
-	return variant;
-}
-
-static gboolean
-_device_wifi_request_scan (NMDeviceWifi *device,
-                           GVariant *options,
-                           GCancellable *cancellable,
-                           GError **error)
-{
-	gboolean ret;
-	GVariant *variant;
-
-	g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), FALSE);
-
-	variant = prepare_scan_options (options);
-
-	ret = nmdbus_device_wifi_call_request_scan_sync (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy,
-	                                                 variant,
-	                                                 cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
 /**
  * nm_device_wifi_request_scan:
  * @device: a #NMDeviceWifi
@@ -339,7 +287,7 @@ nm_device_wifi_request_scan (NMDeviceWifi *device,
                              GCancellable *cancellable,
                              GError **error)
 {
-	return _device_wifi_request_scan (device, NULL, cancellable, error);
+	return nm_device_wifi_request_scan_options (device, NULL, cancellable, error);
 }
 
 /**
@@ -370,76 +318,30 @@ nm_device_wifi_request_scan_options (NMDeviceWifi *device,
                                      GCancellable *cancellable,
                                      GError **error)
 {
-	return _device_wifi_request_scan (device, options, cancellable, error);
+	g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), FALSE);
+	g_return_val_if_fail (!options || g_variant_is_of_type (options, G_VARIANT_TYPE_VARDICT), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
+	g_return_val_if_fail (!error || !*error, FALSE);
+
+	if (!options)
+		options = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
+
+	return _nm_object_dbus_call_sync_void (device,
+	                                       cancellable,
+	                                       g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy)),
+	                                       NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+	                                       "RequestScan",
+	                                       g_variant_new ("(@a{sv})", options),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 NM_BACKPORT_SYMBOL (libnm_1_0_6, gboolean, nm_device_wifi_request_scan_options,
   (NMDeviceWifi *device, GVariant *options, GCancellable *cancellable, GError **error),
   (device, options, cancellable, error));
 
-static void
-request_scan_cb (GObject *source,
-                 GAsyncResult *result,
-                 gpointer user_data)
-{
-	RequestScanInfo *info = user_data;
-	NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (info->device);
-	GError *error = NULL;
-
-	priv->scan_info = NULL;
-
-	if (nmdbus_device_wifi_call_request_scan_finish (NMDBUS_DEVICE_WIFI (source),
-	                                                 result, &error))
-		g_simple_async_result_set_op_res_gboolean (info->simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (info->simple, error);
-	}
-
-	g_simple_async_result_complete (info->simple);
-	g_object_unref (info->simple);
-	g_slice_free (RequestScanInfo, info);
-}
-
-static void
-_device_wifi_request_scan_async (NMDeviceWifi *device,
-                                   GVariant *options,
-                                   GCancellable *cancellable,
-                                   GAsyncReadyCallback callback,
-                                   gpointer user_data)
-{
-	NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
-	RequestScanInfo *info;
-	GSimpleAsyncResult *simple;
-	GVariant *variant;
-
-	g_return_if_fail (NM_IS_DEVICE_WIFI (device));
-
-	simple = g_simple_async_result_new (G_OBJECT (device), callback, user_data,
-	                                    nm_device_wifi_request_scan_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	/* If a scan is in progress, just return */
-	if (priv->scan_info) {
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-		g_simple_async_result_complete_in_idle (simple);
-		g_object_unref (simple);
-		return;
-	}
-
-	info = g_slice_new0 (RequestScanInfo);
-	info->device = device;
-	info->simple = simple;
-
-	variant = prepare_scan_options (options);
-
-	priv->scan_info = info;
-	nmdbus_device_wifi_call_request_scan (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy,
-	                                      variant,
-	                                      cancellable, request_scan_cb, info);
-}
-
 /**
  * nm_device_wifi_request_scan_async:
  * @device: a #NMDeviceWifi
@@ -457,7 +359,7 @@ nm_device_wifi_request_scan_async (NMDeviceWifi *device,
                                    GAsyncReadyCallback callback,
                                    gpointer user_data)
 {
-	_device_wifi_request_scan_async (device, NULL, cancellable, callback, user_data);
+	nm_device_wifi_request_scan_options_async (device, NULL, cancellable, callback, user_data);
 }
 
 /**
@@ -476,6 +378,8 @@ nm_device_wifi_request_scan_async (NMDeviceWifi *device,
  * D-Bus call. Valid options inside the dictionary are:
  * 'ssids' => array of SSIDs (saay)
  *
+ * To complete the request call nm_device_wifi_request_scan_finish().
+ *
  * Since: 1.2
  **/
 void
@@ -485,7 +389,26 @@ nm_device_wifi_request_scan_options_async (NMDeviceWifi *device,
                                            GAsyncReadyCallback callback,
                                            gpointer user_data)
 {
-	_device_wifi_request_scan_async (device, options, cancellable, callback, user_data);
+	g_return_if_fail (NM_IS_DEVICE_WIFI (device));
+	g_return_if_fail (!options || g_variant_is_of_type (options, G_VARIANT_TYPE_VARDICT));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
+
+	if (!options)
+		options = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
+
+	_nm_object_dbus_call (device,
+	                      nm_device_wifi_request_scan_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_WIFI_GET_PRIVATE (device)->proxy)),
+	                      NM_DBUS_INTERFACE_DEVICE_WIRELESS,
+	                      "RequestScan",
+	                      g_variant_new ("(@a{sv})", options),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 NM_BACKPORT_SYMBOL (libnm_1_0_6, void, nm_device_wifi_request_scan_options_async,
@@ -498,7 +421,8 @@ NM_BACKPORT_SYMBOL (libnm_1_0_6, void, nm_device_wifi_request_scan_options_async
  * @result: the result passed to the #GAsyncReadyCallback
  * @error: location for a #GError, or %NULL
  *
- * Gets the result of a call to nm_device_wifi_request_scan_async().
+ * Gets the result of a call to nm_device_wifi_request_scan_async() and
+ * nm_device_wifi_request_scan_options_async().
  *
  * Returns: %TRUE on success, %FALSE on error, in which case @error will be
  * set.
@@ -508,15 +432,10 @@ nm_device_wifi_request_scan_finish (NMDeviceWifi *device,
                                     GAsyncResult *result,
                                     GError **error)
 {
-	GSimpleAsyncResult *simple;
+	g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_wifi_request_scan_async), FALSE);
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (device), nm_device_wifi_request_scan_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 static void
diff --git a/libnm/nm-device.c b/libnm/nm-device.c
index 4acbfbce91..e509ddf2d2 100644
--- a/libnm/nm-device.c
+++ b/libnm/nm-device.c
@@ -10,6 +10,7 @@
 
 #include <libudev.h>
 
+#include "nm-glib-aux/nm-dbus-aux.h"
 #include "nm-libnm-utils.h"
 #include "nm-dbus-interface.h"
 #include "nm-active-connection.h"
@@ -2009,40 +2010,31 @@ nm_device_reapply (NMDevice *device,
                    GCancellable *cancellable,
                    GError **error)
 {
-	GVariant *dict = NULL;
-	gboolean ret;
+	GVariant *arg_connection = NULL;
 
 	g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (!connection || NM_IS_CONNECTION (connection), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
+	g_return_val_if_fail (!error || !*error, FALSE);
 
 	if (connection)
-		dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
-	if (!dict)
-		dict = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
+		arg_connection = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
+	if (!arg_connection)
+		arg_connection = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
 
-	ret = nmdbus_device_call_reapply_sync (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                                       dict, version_id, flags, cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-device_reapply_cb (GObject *proxy,
-                   GAsyncResult *result,
-                   gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_device_call_reapply_finish (NMDBUS_DEVICE (proxy), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (device,
+	                                       cancellable,
+	                                       g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                                       NM_DBUS_INTERFACE_DEVICE,
+	                                       "Reapply",
+	                                       g_variant_new ("(@a{sa{sv}}tu)",
+	                                                      arg_connection,
+	                                                      version_id,
+	                                                      flags),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -2073,24 +2065,33 @@ nm_device_reapply_async (NMDevice *device,
                          GAsyncReadyCallback callback,
                          gpointer user_data)
 {
-	GVariant *dict = NULL;
-	GSimpleAsyncResult *simple;
+	GVariant *arg_connection = NULL;
 
 	g_return_if_fail (NM_IS_DEVICE (device));
+	g_return_if_fail (!connection || NM_IS_CONNECTION (connection));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
 	if (connection)
-		dict = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
-	if (!dict)
-		dict = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
+		arg_connection = nm_connection_to_dbus (connection, NM_CONNECTION_SERIALIZE_ALL);
+	if (!arg_connection)
+		arg_connection = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
 
-	simple = g_simple_async_result_new (G_OBJECT (device), callback, user_data,
-	                                    nm_device_reapply_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_device_call_reapply (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                            dict, version_id, flags, cancellable,
-	                            device_reapply_cb, simple);
+	_nm_object_dbus_call (device,
+	                      nm_device_reapply_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                      NM_DBUS_INTERFACE_DEVICE,
+	                      "Reapply",
+	                      g_variant_new ("(@a{sa{sv}}tu)",
+	                                     arg_connection,
+	                                     version_id,
+	                                     flags),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -2111,15 +2112,10 @@ nm_device_reapply_finish (NMDevice *device,
                           GAsyncResult *result,
                           GError **error)
 {
-	GSimpleAsyncResult *simple;
+	g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_reapply_async), FALSE);
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (device), nm_device_reapply_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /*****************************************************************************/
@@ -2152,80 +2148,42 @@ nm_device_get_applied_connection (NMDevice *device,
                                   GCancellable *cancellable,
                                   GError **error)
 {
-	gs_unref_variant GVariant *dict = NULL;
-	guint64 my_version_id;
-	gboolean success;
+	gs_unref_variant GVariant *ret = NULL;
+	gs_unref_variant GVariant *v_connection = NULL;
+	guint64 v_version_id;
 	NMConnection *connection;
 
 	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
 	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), NULL);
 	g_return_val_if_fail (!error || !*error, NULL);
 
-	success = nmdbus_device_call_get_applied_connection_sync (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                                                          flags, &dict, &my_version_id, cancellable, error);
-	if (!success) {
-		if (error && *error)
-			g_dbus_error_strip_remote_error (*error);
+	ret = _nm_object_dbus_call_sync (device,
+	                                 cancellable,
+	                                 g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                                 NM_DBUS_INTERFACE_DEVICE,
+	                                 "GetAppliedConnection",
+	                                 g_variant_new ("(u)", flags),
+	                                 G_VARIANT_TYPE ("(a{sa{sv}}t)"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret)
 		return NULL;
-	}
 
-	connection = _nm_simple_connection_new_from_dbus (dict, NM_SETTING_PARSE_FLAGS_BEST_EFFORT, error);
+	g_variant_get (ret,
+	               "(@a{sa{sv}}t)",
+	               &v_connection,
+	               &v_version_id);
+
+	connection = _nm_simple_connection_new_from_dbus (v_connection, NM_SETTING_PARSE_FLAGS_BEST_EFFORT, error);
 	if (!connection)
 		return NULL;
 
-	NM_SET_OUT (version_id, my_version_id);
+	NM_SET_OUT (version_id, v_version_id);
 	return connection;
 }
 
-typedef struct {
-	NMConnection *connection;
-	guint64 version_id;
-} GetAppliedConnectionData;
-
-static void
-device_get_applied_connection_data_free (gpointer user_data)
-{
-	GetAppliedConnectionData *data = user_data;
-
-	g_return_if_fail (data);
-
-	g_object_unref (data->connection);
-	g_slice_free (GetAppliedConnectionData, data);
-}
-
-static void
-device_get_applied_connection_cb (GObject *proxy,
-                                  GAsyncResult *result,
-                                  gpointer user_data)
-{
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
-	gs_unref_variant GVariant *dict = NULL;
-	guint64 my_version_id;
-	GError *error = NULL;
-	NMConnection *connection;
-	GetAppliedConnectionData *data;
-
-	if (!nmdbus_device_call_get_applied_connection_finish (NMDBUS_DEVICE (proxy), &dict, &my_version_id, result, &error)) {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-		goto out;
-	}
-
-	connection = _nm_simple_connection_new_from_dbus (dict, NM_SETTING_PARSE_FLAGS_BEST_EFFORT, &error);
-	if (!connection) {
-		g_simple_async_result_take_error (simple, error);
-		goto out;
-	}
-
-	data = g_slice_new (GetAppliedConnectionData);
-	data->connection = connection;
-	data->version_id = my_version_id;
-	g_simple_async_result_set_op_res_gpointer (simple, data, device_get_applied_connection_data_free);
-
-out:
-	g_simple_async_result_complete (simple);
-}
-
 /**
  * nm_device_get_applied_connection_async:
  * @device: a #NMDevice
@@ -2245,19 +2203,22 @@ nm_device_get_applied_connection_async  (NMDevice *device,
                                          GAsyncReadyCallback callback,
                                          gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_if_fail (NM_IS_DEVICE (device));
 	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	simple = g_simple_async_result_new (G_OBJECT (device), callback, user_data,
-	                                    nm_device_get_applied_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_device_call_get_applied_connection (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                                           flags, cancellable,
-	                                           device_get_applied_connection_cb, simple);
+	_nm_object_dbus_call (device,
+	                      nm_device_get_applied_connection_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                      NM_DBUS_INTERFACE_DEVICE,
+	                      "GetAppliedConnection",
+	                      g_variant_new ("(u)", flags),
+	                      G_VARIANT_TYPE ("(a{sa{sv}}t)"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -2284,23 +2245,30 @@ nm_device_get_applied_connection_finish (NMDevice *device,
                                          guint64 *version_id,
                                          GError **error)
 {
-	GSimpleAsyncResult *simple;
-	GetAppliedConnectionData *data;
+	gs_unref_variant GVariant *ret = NULL;
+	gs_unref_variant GVariant *v_connection = NULL;
+	guint64 v_version_id;
+	NMConnection *connection;
 
 	g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (device), nm_device_get_applied_connection_async), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_get_applied_connection_async), NULL);
 	g_return_val_if_fail (!error || !*error, NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret)
 		return NULL;
 
-	data = g_simple_async_result_get_op_res_gpointer (simple);
-	g_return_val_if_fail (data, NULL);
-	g_return_val_if_fail (NM_IS_CONNECTION (data->connection), NULL);
+	g_variant_get (ret,
+	               "(@a{sa{sv}}t)",
+	               &v_connection,
+	               &v_version_id);
 
-	NM_SET_OUT (version_id, data->version_id);
-	return g_object_ref (data->connection);
+	connection = _nm_simple_connection_new_from_dbus (v_connection, NM_SETTING_PARSE_FLAGS_BEST_EFFORT, error);
+	if (!connection)
+		return NULL;
+
+	NM_SET_OUT (version_id, v_version_id);
+	return connection;
 }
 
 /*****************************************************************************/
@@ -2324,34 +2292,20 @@ nm_device_disconnect (NMDevice *device,
                       GCancellable *cancellable,
                       GError **error)
 {
-	gboolean ret;
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
+	g_return_val_if_fail (!error || !*error, FALSE);
 
-	ret = nmdbus_device_call_disconnect_sync (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                                          cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-device_disconnect_cb (GObject *proxy,
-                      GAsyncResult *result,
-                      gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_device_call_disconnect_finish (NMDBUS_DEVICE (proxy), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (device,
+	                                       cancellable,
+	                                       g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                                       NM_DBUS_INTERFACE_DEVICE,
+	                                       "Disconnect",
+	                                       g_variant_new ("()"),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -2371,18 +2325,22 @@ nm_device_disconnect_async (NMDevice *device,
                             GAsyncReadyCallback callback,
                             gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_if_fail (NM_IS_DEVICE (device));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	simple = g_simple_async_result_new (G_OBJECT (device), callback, user_data,
-	                                    nm_device_disconnect_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_device_call_disconnect (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                               cancellable,
-	                               device_disconnect_cb, simple);
+	_nm_object_dbus_call (device,
+	                      nm_device_disconnect_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                      NM_DBUS_INTERFACE_DEVICE,
+	                      "Disconnect",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -2401,15 +2359,10 @@ nm_device_disconnect_finish (NMDevice *device,
                              GAsyncResult *result,
                              GError **error)
 {
-	GSimpleAsyncResult *simple;
+	g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_disconnect_async), FALSE);
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (device), nm_device_disconnect_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /**
@@ -2430,34 +2383,20 @@ nm_device_delete (NMDevice *device,
                   GCancellable *cancellable,
                   GError **error)
 {
-	gboolean ret;
-
 	g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
+	g_return_val_if_fail (!error || !*error, FALSE);
 
-	ret = nmdbus_device_call_delete_sync (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                                      cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-device_delete_cb (GObject *proxy,
-                  GAsyncResult *result,
-                  gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_device_call_delete_finish (NMDBUS_DEVICE (proxy), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (device,
+	                                       cancellable,
+	                                       g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                                       NM_DBUS_INTERFACE_DEVICE,
+	                                       "Delete",
+	                                       g_variant_new ("()"),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -2476,18 +2415,22 @@ nm_device_delete_async (NMDevice *device,
                         GAsyncReadyCallback callback,
                         gpointer user_data)
 {
-	GSimpleAsyncResult *simple;
-
 	g_return_if_fail (NM_IS_DEVICE (device));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	simple = g_simple_async_result_new (G_OBJECT (device), callback, user_data,
-	                                    nm_device_delete_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_device_call_delete (NM_DEVICE_GET_PRIVATE (device)->proxy,
-	                           cancellable,
-	                           device_delete_cb, simple);
+	_nm_object_dbus_call (device,
+	                      nm_device_delete_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_DEVICE_GET_PRIVATE (device)->proxy)),
+	                      NM_DBUS_INTERFACE_DEVICE,
+	                      "Disconnect",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -2506,15 +2449,10 @@ nm_device_delete_finish (NMDevice *device,
                          GAsyncResult *result,
                          GError **error)
 {
-	GSimpleAsyncResult *simple;
+	g_return_val_if_fail (NM_IS_DEVICE (device), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, device, nm_device_delete_async), FALSE);
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (device), nm_device_delete_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /**
diff --git a/libnm/nm-manager.c b/libnm/nm-manager.c
index 11a7796572..1b7449e3ad 100644
--- a/libnm/nm-manager.c
+++ b/libnm/nm-manager.c
@@ -46,7 +46,6 @@ typedef struct {
 	GPtrArray *all_devices;
 	GPtrArray *active_connections;
 	GPtrArray *checkpoints;
-	GSList *added_checkpoints;
 	NMConnectivityState connectivity;
 	NMActiveConnection *primary_connection;
 	NMActiveConnection *activating_connection;
@@ -58,7 +57,9 @@ typedef struct {
 	/* Activations waiting for their NMActiveConnection
 	 * to appear and then their callback to be called.
 	 */
-	CList pending_activations;
+	CList wait_for_active_connection_lst_head;
+
+	CList wait_for_checkpoint_lst_head;
 
 	gboolean networking_enabled;
 	gboolean wireless_enabled;
@@ -119,21 +120,21 @@ static guint signals[LAST_SIGNAL] = { 0 };
 /*****************************************************************************/
 
 typedef struct {
-	NMManager *manager;
-	GSimpleAsyncResult *simple;
-	char *path;
+	CList lst;
+	NMManager *self;
+	char *checkpoint_path;
+	GTask *task;
+	gulong cancelled_id;
 } CheckpointInfo;
 
 static CheckpointInfo *
-find_checkpoint_info (NMManager *manager, const char *path)
+_wait_for_checkpoint_find_info (NMManager *manager, const char *path)
 {
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 	CheckpointInfo *info;
-	GSList *iter;
 
-	for (iter = priv->added_checkpoints; iter; iter = g_slist_next (iter)) {
-		info = iter->data;
-		if (nm_streq0 (path, info->path))
+	c_list_for_each_entry (info, &priv->wait_for_checkpoint_lst_head, lst) {
+		if (nm_streq (path, info->checkpoint_path))
 			return info;
 	}
 
@@ -141,28 +142,23 @@ find_checkpoint_info (NMManager *manager, const char *path)
 }
 
 static void
-checkpoint_info_complete (NMManager *self,
-                          CheckpointInfo *info,
-                          NMCheckpoint *checkpoint,
-                          GError *error)
+_wait_for_checkpoint_complete (CheckpointInfo *info,
+                               NMCheckpoint *checkpoint,
+                               GError *error)
 {
-	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
+	c_list_unlink_stale (&info->lst);
 
-	g_return_if_fail (info);
+	nm_clear_g_signal_handler (g_task_get_cancellable (info->task), &info->cancelled_id);
 
-	if (checkpoint) {
-		g_simple_async_result_set_op_res_gpointer (info->simple,
-		                                           g_object_ref (checkpoint),
-		                                           g_object_unref);
-	} else
-		g_simple_async_result_set_from_error (info->simple, error);
-	g_simple_async_result_complete (info->simple);
+	if (!checkpoint)
+		g_task_return_error (info->task, error);
+	else
+		g_task_return_pointer (info->task, g_object_ref (checkpoint), g_object_unref);
 
-	g_object_unref (info->simple);
-	priv->added_checkpoints = g_slist_remove (priv->added_checkpoints, info);
-
-	g_free (info->path);
-	g_slice_free (CheckpointInfo, info);
+	g_object_unref (info->task);
+	g_object_unref (info->self);
+	g_free (info->checkpoint_path);
+	nm_g_slice_free (info);
 }
 
 static void
@@ -170,7 +166,8 @@ nm_manager_init (NMManager *manager)
 {
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 
-	c_list_init (&priv->pending_activations);
+	c_list_init (&priv->wait_for_active_connection_lst_head);
+	c_list_init (&priv->wait_for_checkpoint_lst_head);
 
 	priv->state = NM_STATE_UNKNOWN;
 	priv->connectivity = NM_CONNECTIVITY_UNKNOWN;
@@ -250,12 +247,12 @@ object_creation_failed (NMObject *object, const char *failed_path)
 	CheckpointInfo *info;
 	GError *add_error;
 
-	info = find_checkpoint_info (self, failed_path);
+	info = _wait_for_checkpoint_find_info (self, failed_path);
 	if (info) {
 		add_error = g_error_new_literal (NM_CLIENT_ERROR,
 		                                 NM_CLIENT_ERROR_OBJECT_CREATION_FAILED,
 		                                 _("Checkpoint was removed before it was initialized"));
-		checkpoint_info_complete (self, info, NULL, add_error);
+		_wait_for_checkpoint_complete (info, NULL, add_error);
 		g_error_free (add_error);
 	}
 }
@@ -376,46 +373,65 @@ get_permissions_reply (GObject *object,
 {
 	NMManager *self;
 	NMManagerPrivate *priv;
-	GVariant *permissions = NULL;
-	GError *error = NULL;
+	gs_unref_variant GVariant *ret = NULL;
+	gs_unref_variant GVariant *permissions = NULL;
+	gs_free_error GError *error = NULL;
 
-	/* WARNING: this may be called after the manager is disposed, so we can't
-	 * look at self/priv until after we've determined that that isn't the case.
-	 */
-
-	nmdbus_manager_call_get_permissions_finish (NMDBUS_MANAGER (object),
-	                                            &permissions,
-	                                            result, &error);
-	if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
-		/* @self has been disposed. */
-		g_error_free (error);
-		return;
+	ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (object), result, &error);
+	if (!ret) {
+		if (nm_utils_error_is_cancelled (error, FALSE))
+			return;
+	} else {
+		g_variant_get (ret,
+		               "(@a{ss})",
+		               &permissions);
 	}
 
 	self = user_data;
 	priv = NM_MANAGER_GET_PRIVATE (self);
 
-	update_permissions (self, permissions);
-
-	g_clear_pointer (&permissions, g_variant_unref);
-	g_clear_error (&error);
 	g_clear_object (&priv->perm_call_cancellable);
+
+	update_permissions (self, permissions);
 }
 
 static void
-manager_recheck_permissions (NMDBusManager *proxy, gpointer user_data)
+manager_recheck_permissions (NMDBusManager *_unused_proxy, gpointer user_data)
 {
 	NMManager *self = NM_MANAGER (user_data);
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
+	const char *name_owner;
 
-	if (priv->perm_call_cancellable)
+	/* If a request is already pending, then we cancel it. We anyway
+	 * need to make a new request, to be sure that we picked up on all
+	 * the latest changes since the "CheckPermission" signal.
+	 *
+	 * However, we cannot accept more than one "GetPermissions" request
+	 * in flight. That is because NetworkManager needs to ask PolicyKit
+	 * for each permission individually, and some of these permission
+	 * requests might be answered before others. Hence, the collection
+	 * of all permissions is not taken at one point in time. Hence, when
+	 * we would allow for multiple GetPermissions requests in-flight,
+	 * we wouldn't know which response reflects the latest state. */
+	nm_clear_g_cancellable (&priv->perm_call_cancellable);
+
+	name_owner = _nm_object_get_dbus_name_owner (self);
+	if (!name_owner)
 		return;
 
 	priv->perm_call_cancellable = g_cancellable_new ();
-	nmdbus_manager_call_get_permissions (priv->proxy,
-	                                     priv->perm_call_cancellable,
-	                                     get_permissions_reply,
-	                                     self);
+	g_dbus_connection_call (_nm_object_get_dbus_connection (self),
+	                        name_owner,
+	                        NM_DBUS_PATH,
+	                        NM_DBUS_INTERFACE,
+	                        "GetPermissions",
+	                        g_variant_new ("()"),
+	                        G_VARIANT_TYPE ("(a{ss})"),
+	                        G_DBUS_CALL_FLAGS_NONE,
+	                        NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                        priv->perm_call_cancellable,
+	                        get_permissions_reply,
+	                        self);
 }
 
 const char *
@@ -451,18 +467,31 @@ nm_manager_networking_get_enabled (NMManager *manager)
 }
 
 gboolean
-nm_manager_networking_set_enabled (NMManager *manager, gboolean enable, GError **error)
+_nm_manager_networking_set_enabled (GDBusConnection *dbus_connection,
+                                    const char *name_owner,
+                                    gboolean enable,
+                                    GError **error)
 {
-	gboolean ret;
+	gs_unref_variant GVariant *ret = NULL;
 
-	g_return_val_if_fail (NM_IS_MANAGER (manager), FALSE);
+	ret = g_dbus_connection_call_sync (dbus_connection,
+	                                   name_owner,
+	                                   NM_DBUS_PATH,
+	                                   NM_DBUS_INTERFACE,
+	                                   "Enable",
+	                                   g_variant_new ("(b)", enable),
+	                                   G_VARIANT_TYPE ("()"),
+	                                   G_DBUS_CALL_FLAGS_NONE,
+	                                   NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                   NULL,
+	                                   error);
+	if (!ret) {
+		if (error)
+			g_dbus_error_strip_remote_error (*error);
+		return FALSE;
+	}
 
-	ret = nmdbus_manager_call_enable_sync (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                       enable,
-	                                       NULL, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
+	return TRUE;
 }
 
 gboolean
@@ -577,51 +606,6 @@ nm_manager_connectivity_check_get_uri (NMManager *manager)
 	return nmdbus_manager_get_connectivity_check_uri (NM_MANAGER_GET_PRIVATE (manager)->proxy);
 }
 
-gboolean
-nm_manager_get_logging (NMManager *manager, char **level, char **domains, GError **error)
-{
-	gboolean ret;
-
-	g_return_val_if_fail (NM_IS_MANAGER (manager), FALSE);
-	g_return_val_if_fail (level == NULL || *level == NULL, FALSE);
-	g_return_val_if_fail (domains == NULL || *domains == NULL, FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	if (!level && !domains)
-		return TRUE;
-
-	ret = nmdbus_manager_call_get_logging_sync (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                            level, domains,
-	                                            NULL, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-gboolean
-nm_manager_set_logging (NMManager *manager, const char *level, const char *domains, GError **error)
-{
-	gboolean ret;
-
-	g_return_val_if_fail (NM_IS_MANAGER (manager), FALSE);
-	g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
-
-	if (!level && !domains)
-		return TRUE;
-
-	if (!level)
-		level = "";
-	if (!domains)
-		domains = "";
-
-	ret = nmdbus_manager_call_set_logging_sync (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                            level, domains,
-	                                            NULL, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
 NMClientPermissionResult
 nm_manager_get_permission_result (NMManager *manager, NMClientPermission permission)
 {
@@ -642,99 +626,16 @@ nm_manager_get_connectivity (NMManager *manager)
 	return NM_MANAGER_GET_PRIVATE (manager)->connectivity;
 }
 
-NMConnectivityState
-nm_manager_check_connectivity (NMManager *manager,
-                               GCancellable *cancellable,
-                               GError **error)
-{
-	NMManagerPrivate *priv;
-	guint32 connectivity;
-
-	g_return_val_if_fail (NM_IS_MANAGER (manager), NM_CONNECTIVITY_UNKNOWN);
-	priv = NM_MANAGER_GET_PRIVATE (manager);
-
-	if (nmdbus_manager_call_check_connectivity_sync (priv->proxy,
-	                                                 &connectivity,
-	                                                 cancellable, error)) {
-		if (connectivity != priv->connectivity) {
-			priv->connectivity = connectivity;
-			g_object_notify (G_OBJECT (manager), NM_MANAGER_CONNECTIVITY);
-		}
-		return connectivity;
-	}
-	else {
-		if (error && *error)
-			g_dbus_error_strip_remote_error (*error);
-		return NM_CONNECTIVITY_UNKNOWN;
-	}
-}
-
-static void
-check_connectivity_cb (GObject *object,
-                       GAsyncResult *result,
-                       gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	guint32 connectivity;
-	GError *error = NULL;
-	NMManager *manager;
-	NMManagerPrivate *priv;
-
-	if (nmdbus_manager_call_check_connectivity_finish (NMDBUS_MANAGER (object),
-	                                                   &connectivity,
-	                                                   result, &error)) {
-		g_simple_async_result_set_op_res_gssize (simple, connectivity);
-
-		manager = NM_MANAGER (g_async_result_get_source_object (G_ASYNC_RESULT (simple)));
-		priv = NM_MANAGER_GET_PRIVATE (manager);
-		if (connectivity != priv->connectivity) {
-			priv->connectivity = connectivity;
-			g_object_notify (G_OBJECT (manager), NM_MANAGER_CONNECTIVITY);
-		}
-	} else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
 void
-nm_manager_check_connectivity_async (NMManager *manager,
-                                     GCancellable *cancellable,
-                                     GAsyncReadyCallback callback,
-                                     gpointer user_data)
+_nm_manager_set_connectivity_hack (NMManager *manager,
+                                   guint32 connectivity)
 {
-	NMManagerPrivate *priv;
-	GSimpleAsyncResult *simple;
+	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
 
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	priv = NM_MANAGER_GET_PRIVATE (manager);
-
-	simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                    nm_manager_check_connectivity_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nmdbus_manager_call_check_connectivity (priv->proxy,
-	                                        cancellable,
-	                                        check_connectivity_cb, simple);
-}
-
-NMConnectivityState
-nm_manager_check_connectivity_finish (NMManager *manager,
-                                      GAsyncResult *result,
-                                      GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager), nm_manager_check_connectivity_async), NM_CONNECTIVITY_UNKNOWN);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NM_CONNECTIVITY_UNKNOWN;
-	return (NMConnectivityState) g_simple_async_result_get_op_res_gssize (simple);
+	if ((NMConnectivityState) connectivity != priv->connectivity) {
+		priv->connectivity = (NMConnectivityState) connectivity;
+		g_object_notify (G_OBJECT (manager), NM_MANAGER_CONNECTIVITY);
+	}
 }
 
 /*****************************************************************************/
@@ -850,10 +751,8 @@ typedef enum {
 typedef struct {
 	CList lst;
 	NMManager *manager;
-	GSimpleAsyncResult *simple;
-	GCancellable *cancellable;
+	GTask *task;
 	char *active_path;
-	char *new_connection_path;
 	GVariant *add_and_activate_output;
 	gulong cancelled_id;
 	ActivateType activate_type;
@@ -871,7 +770,7 @@ _nm_activate_result_new (NMActiveConnection *active,
 	r = g_slice_new (_NMActivateResult);
 	*r = (_NMActivateResult) {
 		.active                  = g_object_ref (active),
-		.add_and_activate_output = nm_g_variant_ref (add_and_activate_output),
+		.add_and_activate_output = g_steal_pointer (&add_and_activate_output),
 	};
 	return r;
 }
@@ -879,7 +778,7 @@ _nm_activate_result_new (NMActiveConnection *active,
 void
 _nm_activate_result_free (_NMActivateResult *result)
 {
-	g_object_unref (result->active);
+	nm_g_object_unref (result->active);
 	nm_g_variant_unref (result->add_and_activate_output);
 	g_slice_free (_NMActivateResult, result);
 }
@@ -889,27 +788,27 @@ activate_info_complete (ActivateInfo *info,
                         NMActiveConnection *active,
                         GError *error)
 {
+	nm_assert (info);
+	nm_assert (info->task);
+	nm_assert (G_IS_TASK (info->task));
 	nm_assert ((!error) != (!active));
 
-	nm_clear_g_signal_handler (info->cancellable, &info->cancelled_id);
-
 	c_list_unlink_stale (&info->lst);
 
-	if (active) {
-		g_simple_async_result_set_op_res_gpointer (info->simple,
-		                                           _nm_activate_result_new (active,
-		                                                                    info->add_and_activate_output),
-		                                           (GDestroyNotify) _nm_activate_result_free);
-	} else
-		g_simple_async_result_set_from_error (info->simple, error);
+	nm_clear_g_signal_handler (g_task_get_cancellable (info->task), &info->cancelled_id);
 
-	g_simple_async_result_complete (info->simple);
+	if (error)
+		g_task_return_error (info->task, error);
+	else {
+		g_task_return_pointer (info->task,
+		                       _nm_activate_result_new (active,
+		                                                g_steal_pointer (&info->add_and_activate_output)),
+		                       (GDestroyNotify) _nm_activate_result_free);
+	}
 
 	nm_g_variant_unref (info->add_and_activate_output);
 	g_free (info->active_path);
-	g_free (info->new_connection_path);
-	g_object_unref (info->simple);
-	nm_g_object_unref (info->cancellable);
+	g_object_unref (info->task);
 	g_slice_free (ActivateInfo, info);
 }
 
@@ -931,15 +830,14 @@ find_active_connection_by_path (NMManager *self, const char *ac_path)
 }
 
 static void
-recheck_pending_activations (NMManager *self)
+_wait_for_active_connections_check (NMManager *self)
 {
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
-	CList *iter, *safe;
+	CList *iter;
 	NMActiveConnection *candidate;
 	const GPtrArray *devices;
 	NMDevice *device;
-	GDBusObjectManager *object_manager = NULL;
-	GError *error;
+	GDBusObjectManager *object_manager;
 
 	object_manager = _nm_object_get_dbus_object_manager (NM_OBJECT (self));
 
@@ -948,23 +846,23 @@ recheck_pending_activations (NMManager *self)
 	 * device have both updated their properties to point to each other, and
 	 * call the pending connection's callback.
 	 */
-	c_list_for_each_safe (iter, safe, &priv->pending_activations) {
+again:
+	c_list_for_each (iter, &priv->wait_for_active_connection_lst_head) {
 		ActivateInfo *info = c_list_entry (iter, ActivateInfo, lst);
 		gs_unref_object GDBusObject *dbus_obj = NULL;
 
-		if (!info->active_path)
-			continue;
+		nm_assert (info->active_path);
 
 		/* Check that the object manager still knows about the object.
 		 * It could be that it vanished before we even learned its name. */
 		dbus_obj = g_dbus_object_manager_get_object (object_manager, info->active_path);
 		if (!dbus_obj) {
-			error = g_error_new_literal (NM_CLIENT_ERROR,
-			                             NM_CLIENT_ERROR_OBJECT_CREATION_FAILED,
-			                             _("Active connection removed before it was initialized"));
-			activate_info_complete (info, NULL, error);
-			g_clear_error (&error);
-			break;
+			activate_info_complete (info,
+			                        NULL,
+			                        g_error_new_literal (NM_CLIENT_ERROR,
+			                                             NM_CLIENT_ERROR_OBJECT_CREATION_FAILED,
+			                                             _("Active connection removed before it was initialized")));
+			goto again;
 		}
 
 		candidate = find_active_connection_by_path (self, info->active_path);
@@ -983,246 +881,72 @@ recheck_pending_activations (NMManager *self)
 		}
 
 		activate_info_complete (info, candidate, NULL);
-		break;
+		goto again;
 	}
 }
 
 static void
-activation_cancelled (GCancellable *cancellable,
-                      gpointer user_data)
+_wait_for_active_connection_cancelled_cb (GCancellable *cancellable,
+                                          gpointer user_data)
 {
 	ActivateInfo *info = user_data;
-	GError *error = NULL;
+	gs_free_error GError *error = NULL;
 
 	if (!g_cancellable_set_error_if_cancelled (cancellable, &error))
 		return;
 
-	activate_info_complete (info, NULL, error);
-	g_clear_error (&error);
-}
-
-static void
-activate_cb (GObject *object,
-             GAsyncResult *result,
-             gpointer user_data)
-{
-	ActivateInfo *info = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_manager_call_activate_connection_finish (NMDBUS_MANAGER (object),
-	                                                    &info->active_path,
-	                                                    result, &error)) {
-		if (info->cancellable) {
-			info->cancelled_id = g_signal_connect (info->cancellable, "cancelled",
-			                                       G_CALLBACK (activation_cancelled), info);
-		}
-
-		recheck_pending_activations (info->manager);
-	} else {
-		g_dbus_error_strip_remote_error (error);
-		activate_info_complete (info, NULL, error);
-		g_clear_error (&error);
-	}
+	activate_info_complete (info, NULL, g_steal_pointer (&error));
 }
 
 void
-nm_manager_activate_connection_async (NMManager *manager,
-                                      NMConnection *connection,
-                                      NMDevice *device,
-                                      const char *specific_object,
-                                      GCancellable *cancellable,
-                                      GAsyncReadyCallback callback,
-                                      gpointer user_data)
+nm_manager_wait_for_active_connection (NMManager *self,
+                                       const char *active_path,
+                                       const char *connection_path,
+                                       GVariant *add_and_activate_output_take,
+                                       GTask *task_take)
 {
-	NMManagerPrivate *priv;
+	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
+	gs_unref_object GTask *task = task_take;
+	gs_unref_variant GVariant *add_and_activate_output = add_and_activate_output_take;
 	ActivateInfo *info;
+	GCancellable *cancellable;
 
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	if (device)
-		g_return_if_fail (NM_IS_DEVICE (device));
-	if (connection)
-		g_return_if_fail (NM_IS_CONNECTION (connection));
+	nm_assert (NM_IS_MANAGER (self));
+	nm_assert (active_path);
+	nm_assert (G_IS_TASK (task));
 
-	priv = NM_MANAGER_GET_PRIVATE (manager);
+	/* FIXME: there is no timeout for how long we wait. But this entire
+	 * code will be reworked, also that we have a suitable GMainContext
+	 * where we can schedule the timeout (we shouldn't use g_main_context_default()). */
 
-	info = g_slice_new0 (ActivateInfo);
-	info->activate_type = ACTIVATE_TYPE_ACTIVATE_CONNECTION;
-	info->manager = manager;
-	info->simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                          nm_manager_activate_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (info->simple, cancellable);
-	info->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
+	info = g_slice_new (ActivateInfo);
+	*info = (ActivateInfo) {
+		.manager                 = g_object_ref (self),
+		.task                    = g_steal_pointer (&task),
+		.active_path             = g_strdup (active_path),
+		.add_and_activate_output = g_steal_pointer (&add_and_activate_output),
+	};
+	c_list_link_tail (&priv->wait_for_active_connection_lst_head, &info->lst);
 
-	c_list_link_tail (&priv->pending_activations, &info->lst);
-
-	nmdbus_manager_call_activate_connection (priv->proxy,
-	                                         connection ? nm_connection_get_path (connection) : "/",
-	                                         device ? nm_object_get_path (NM_OBJECT (device)) : "/",
-	                                         specific_object ?: "/",
-	                                         cancellable,
-	                                         activate_cb, info);
-}
-
-NMActiveConnection *
-nm_manager_activate_connection_finish (NMManager *manager,
-                                       GAsyncResult *result,
-                                       GError **error)
-{
-	GSimpleAsyncResult *simple;
-	_NMActivateResult *r;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager), nm_manager_activate_connection_async), NULL);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NULL;
-
-	r = g_simple_async_result_get_op_res_gpointer (simple);
-	return g_object_ref (r->active);
-}
-
-static void
-add_activate_cb (GObject *object,
-                 GAsyncResult *result,
-                 gpointer user_data)
-{
-	ActivateInfo *info = user_data;
-	gs_free_error GError *error = NULL;
-	gboolean success;
-
-	nm_assert (info);
-	nm_assert (!info->active_path);
-	nm_assert (!info->add_and_activate_output);
-
-	if (info->activate_type == ACTIVATE_TYPE_ADD_AND_ACTIVATE_CONNECTION) {
-		success = nmdbus_manager_call_add_and_activate_connection_finish (NMDBUS_MANAGER (object),
-		                                                                  NULL,
-		                                                                  &info->active_path,
-		                                                                  result,
-		                                                                  &error);
-	} else {
-		success = nmdbus_manager_call_add_and_activate_connection2_finish (NMDBUS_MANAGER (object),
-		                                                                   NULL,
-		                                                                   &info->active_path,
-		                                                                   &info->add_and_activate_output,
-		                                                                   result,
-		                                                                   &error);
-	}
-	if (!success) {
-		g_dbus_error_strip_remote_error (error);
-		activate_info_complete (info, NULL, error);
-		return;
-	}
-
-	if (info->cancellable) {
-		info->cancelled_id = g_signal_connect (info->cancellable, "cancelled",
-		                                       G_CALLBACK (activation_cancelled), info);
-	}
-
-	recheck_pending_activations (info->manager);
-}
-
-void
-nm_manager_add_and_activate_connection_async (NMManager *manager,
-                                              NMConnection *partial,
-                                              NMDevice *device,
-                                              const char *specific_object,
-                                              GVariant *options,
-                                              gboolean force_v2,
-                                              GCancellable *cancellable,
-                                              GAsyncReadyCallback callback,
-                                              gpointer user_data)
-{
-	NMManagerPrivate *priv;
-	GVariant *dict = NULL;
-	ActivateInfo *info;
-	ActivateType activate_type = ACTIVATE_TYPE_ADD_AND_ACTIVATE_CONNECTION;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	g_return_if_fail (NM_IS_DEVICE (device));
-	if (partial)
-		g_return_if_fail (NM_IS_CONNECTION (partial));
-
-	priv = NM_MANAGER_GET_PRIVATE (manager);
-
-	info = g_slice_new0 (ActivateInfo);
-	info->manager = manager;
-	info->simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                          nm_manager_add_and_activate_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (info->simple, cancellable);
-	info->cancellable = cancellable ? g_object_ref (cancellable) : NULL;
-
-	c_list_link_tail (&priv->pending_activations, &info->lst);
-
-	if (partial)
-		dict = nm_connection_to_dbus (partial, NM_CONNECTION_SERIALIZE_ALL);
-	if (!dict)
-		dict = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
-	if (force_v2) {
-		if (!options)
-			options = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
-		activate_type = ACTIVATE_TYPE_ADD_AND_ACTIVATE_CONNECTION2;
-	} else {
-		if (options) {
-			if (g_variant_n_children (options) > 0)
-				activate_type = ACTIVATE_TYPE_ADD_AND_ACTIVATE_CONNECTION2;
-			else
-				nm_g_variant_unref_floating (options);
+	cancellable = g_task_get_cancellable (info->task);
+	if (cancellable) {
+		info->cancelled_id = g_signal_connect (cancellable,
+		                                       "cancelled",
+		                                       G_CALLBACK (_wait_for_active_connection_cancelled_cb),
+		                                       info);
+		if (g_cancellable_is_cancelled (cancellable)) {
+			_wait_for_active_connection_cancelled_cb (cancellable, info);
+			return;
 		}
 	}
 
-	info->activate_type = activate_type;
-
-	if (activate_type == ACTIVATE_TYPE_ADD_AND_ACTIVATE_CONNECTION2) {
-		nmdbus_manager_call_add_and_activate_connection2 (priv->proxy,
-		                                                  dict,
-		                                                  nm_object_get_path (NM_OBJECT (device)),
-		                                                  specific_object ?: "/",
-		                                                  options,
-		                                                  cancellable,
-		                                                  add_activate_cb,
-		                                                  info);
-	} else {
-		nmdbus_manager_call_add_and_activate_connection (priv->proxy,
-		                                                 dict,
-		                                                 nm_object_get_path (NM_OBJECT (device)),
-		                                                 specific_object ?: "/",
-		                                                 cancellable,
-		                                                 add_activate_cb,
-		                                                 info);
-	}
-}
-
-NMActiveConnection *
-nm_manager_add_and_activate_connection_finish (NMManager *manager,
-                                               GAsyncResult *result,
-                                               GVariant **out_result,
-                                               GError **error)
-{
-	GSimpleAsyncResult *simple;
-	_NMActivateResult *r;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager), nm_manager_add_and_activate_connection_async), NULL);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error)) {
-		NM_SET_OUT (out_result, NULL);
-		return NULL;
-	}
-
-	r = g_simple_async_result_get_op_res_gpointer (simple);
-	NM_SET_OUT (out_result, nm_g_variant_ref (r->add_and_activate_output));
-	return g_object_ref (r->active);
+	_wait_for_active_connections_check (self);
 }
 
 static void
 device_ac_changed (GObject *object, GParamSpec *pspec, gpointer user_data)
 {
-	NMManager *self = user_data;
-
-	recheck_pending_activations (self);
+	_wait_for_active_connections_check (user_data);
 }
 
 static void
@@ -1241,9 +965,7 @@ device_removed (NMManager *self, NMDevice *device)
 static void
 ac_devices_changed (GObject *object, GParamSpec *pspec, gpointer user_data)
 {
-	NMManager *self = user_data;
-
-	recheck_pending_activations (self);
+	_wait_for_active_connections_check (user_data);
 }
 
 static void
@@ -1251,14 +973,14 @@ active_connection_added (NMManager *self, NMActiveConnection *ac)
 {
 	g_signal_connect_object (ac, "notify::" NM_ACTIVE_CONNECTION_DEVICES,
 	                         G_CALLBACK (ac_devices_changed), self, 0);
-	recheck_pending_activations (self);
+	_wait_for_active_connections_check (self);
 }
 
 static void
 active_connection_removed (NMManager *self, NMActiveConnection *ac)
 {
 	g_signal_handlers_disconnect_by_func (ac, G_CALLBACK (ac_devices_changed), self);
-	recheck_pending_activations (self);
+	_wait_for_active_connections_check (self);
 }
 
 static void
@@ -1266,90 +988,9 @@ checkpoint_added (NMManager *manager, NMCheckpoint *checkpoint)
 {
 	CheckpointInfo *info;
 
-	info = find_checkpoint_info (manager, nm_object_get_path (NM_OBJECT (checkpoint)));
+	info = _wait_for_checkpoint_find_info (manager, nm_object_get_path (NM_OBJECT (checkpoint)));
 	if (info)
-		checkpoint_info_complete (manager, info, checkpoint, NULL);
-}
-
-gboolean
-nm_manager_deactivate_connection (NMManager *manager,
-                                  NMActiveConnection *active,
-                                  GCancellable *cancellable,
-                                  GError **error)
-{
-	const char *path;
-	gboolean ret;
-
-	g_return_val_if_fail (NM_IS_MANAGER (manager), FALSE);
-	g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (active), FALSE);
-
-	path = nm_object_get_path (NM_OBJECT (active));
-	ret = nmdbus_manager_call_deactivate_connection_sync (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                                      path,
-	                                                      cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-deactivated_cb (GObject *object,
-                GAsyncResult *result,
-                gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_manager_call_deactivate_connection_finish (NMDBUS_MANAGER (object),
-	                                                      result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
-void
-nm_manager_deactivate_connection_async (NMManager *manager,
-                                        NMActiveConnection *active,
-                                        GCancellable *cancellable,
-                                        GAsyncReadyCallback callback,
-                                        gpointer user_data)
-{
-	const char *path;
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	g_return_if_fail (NM_IS_ACTIVE_CONNECTION (active));
-
-	simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                    nm_manager_deactivate_connection_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	path = nm_object_get_path (NM_OBJECT (active));
-	nmdbus_manager_call_deactivate_connection (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                           path,
-	                                           cancellable,
-	                                           deactivated_cb, simple);
-}
-
-gboolean
-nm_manager_deactivate_connection_finish (NMManager *manager,
-                                         GAsyncResult *result,
-                                         GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager), nm_manager_deactivate_connection_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+		_wait_for_checkpoint_complete (info, checkpoint, NULL);
 }
 
 /*****************************************************************************/
@@ -1372,21 +1013,6 @@ free_active_connections (NMManager *manager)
 
 /*****************************************************************************/
 
-static const char **
-get_device_paths (const GPtrArray *devices)
-{
-	const char **array;
-	guint i;
-
-	array = g_new (const char *, devices->len + 1);
-	for (i = 0; i < devices->len; i++)
-		array[i] = nm_object_get_path (NM_OBJECT (devices->pdata[i]));
-
-	array[i] = NULL;
-
-	return array;
-}
-
 const GPtrArray *
 nm_manager_get_checkpoints (NMManager *manager)
 {
@@ -1396,330 +1022,58 @@ nm_manager_get_checkpoints (NMManager *manager)
 }
 
 static void
-checkpoint_created_cb (GObject *object,
-                       GAsyncResult *result,
-                       gpointer user_data)
+_wait_for_checkpoint_cancelled_cb (GCancellable *cancellable,
+                                   gpointer user_data)
 {
 	CheckpointInfo *info = user_data;
-	NMManager *self = info->manager;
 	gs_free_error GError *error = NULL;
+
+	if (!g_cancellable_set_error_if_cancelled (cancellable, &error))
+		return;
+
+	_wait_for_checkpoint_complete (info, NULL, g_steal_pointer (&error));
+}
+
+void
+nm_manager_wait_for_checkpoint (NMManager *self,
+                                const char *checkpoint_path,
+                                GTask *task_take)
+{
+	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
+	gs_unref_object GTask *task = task_take;
+	CheckpointInfo *info;
+	GCancellable *cancellable;
 	NMCheckpoint *checkpoint;
 
-	nmdbus_manager_call_checkpoint_create_finish (NMDBUS_MANAGER (object),
-	                                              &info->path, result, &error);
-	if (error) {
-		g_dbus_error_strip_remote_error (error);
-		checkpoint_info_complete (self, info, NULL, error);
+	checkpoint = get_checkpoint_by_path (self, checkpoint_path);
+	if (checkpoint) {
+		g_task_return_pointer (task, g_object_ref (checkpoint), g_object_unref);
 		return;
 	}
 
-	checkpoint = get_checkpoint_by_path (self, info->path);
-	if (!checkpoint) {
-		/* this is really problematic. The async request returned, but
-		 * we don't yet have a visible (fully initialized) NMCheckpoint instance
-		 * to return. Wait longer for it to appear. However, it's ugly. */
-		return;
+	/* FIXME: there is no timeout for how long we wait. But this entire
+	 * code will be reworked, also that we have a suitable GMainContext
+	 * where we can schedule the timeout (we shouldn't use g_main_context_default()). */
+
+	info = g_slice_new (CheckpointInfo);
+	*info = (CheckpointInfo) {
+		.self            = g_object_ref (self),
+		.task            = g_steal_pointer (&task),
+		.checkpoint_path = g_strdup (checkpoint_path),
+	};
+	c_list_link_tail (&priv->wait_for_checkpoint_lst_head, &info->lst);
+
+	cancellable = g_task_get_cancellable (info->task);
+	if (cancellable) {
+		info->cancelled_id = g_signal_connect (cancellable,
+		                                       "cancelled",
+		                                       G_CALLBACK (_wait_for_checkpoint_cancelled_cb),
+		                                       info);
+		if (g_cancellable_is_cancelled (cancellable)) {
+			_wait_for_checkpoint_cancelled_cb (cancellable, info);
+			return;
+		}
 	}
-
-	checkpoint_info_complete (self, info, checkpoint, NULL);
-}
-
-void
-nm_manager_checkpoint_create (NMManager *manager,
-                              const GPtrArray *devices,
-                              guint32 rollback_timeout,
-                              NMCheckpointCreateFlags flags,
-                              GCancellable *cancellable,
-                              GAsyncReadyCallback callback,
-                              gpointer user_data)
-{
-	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (manager);
-	gs_free const char **paths = NULL;
-	CheckpointInfo *info;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-
-	info = g_slice_new0 (CheckpointInfo);
-	info->manager = manager;
-	info->simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                          nm_manager_checkpoint_create);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (info->simple, cancellable);
-	paths = get_device_paths (devices);
-	nmdbus_manager_call_checkpoint_create (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                       paths,
-	                                       rollback_timeout,
-	                                       flags,
-	                                       cancellable,
-	                                       checkpoint_created_cb,
-	                                       info);
-	priv->added_checkpoints = g_slist_append (priv->added_checkpoints, info);
-}
-
-NMCheckpoint *
-nm_manager_checkpoint_create_finish (NMManager *manager,
-                                     GAsyncResult *result,
-                                     GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (NM_IS_MANAGER (manager), NULL);
-	g_return_val_if_fail (G_IS_SIMPLE_ASYNC_RESULT (result), NULL);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NULL;
-	else
-		return g_object_ref (g_simple_async_result_get_op_res_gpointer (simple));
-}
-
-static void
-checkpoint_destroy_cb (GObject *object,
-                       GAsyncResult *result,
-                       gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_manager_call_checkpoint_destroy_finish (NMDBUS_MANAGER (object),
-	                                                   result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
-void
-nm_manager_checkpoint_destroy (NMManager *manager,
-                               const char *checkpoint_path,
-                               GCancellable *cancellable,
-                               GAsyncReadyCallback callback,
-                               gpointer user_data)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
-
-	simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                    nm_manager_checkpoint_destroy);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_manager_call_checkpoint_destroy (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                        checkpoint_path,
-	                                        cancellable,
-	                                        checkpoint_destroy_cb, simple);
-}
-
-gboolean
-nm_manager_checkpoint_destroy_finish (NMManager *manager,
-                                      GAsyncResult *result,
-                                      GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager),
-	                                                      nm_manager_checkpoint_destroy),
-	                      FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
-}
-
-static void
-checkpoint_rollback_cb (GObject *object,
-                        GAsyncResult *result,
-                        gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-	GVariant *variant = NULL;
-	GVariantIter iter;
-	GHashTable *hash;
-	const char *path;
-	guint r;
-
-	if (nmdbus_manager_call_checkpoint_rollback_finish (NMDBUS_MANAGER (object),
-	                                                    &variant,
-	                                                    result,
-	                                                    &error)) {
-		hash = g_hash_table_new_full (nm_str_hash, g_str_equal, g_free, NULL);
-		g_variant_iter_init (&iter, variant);
-		while (g_variant_iter_next (&iter, "{&su}", &path, &r))
-			g_hash_table_insert (hash, g_strdup (path), GUINT_TO_POINTER (r));
-		g_simple_async_result_set_op_res_gpointer (simple, hash, (GDestroyNotify) g_hash_table_unref);
-	} else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
-void
-nm_manager_checkpoint_rollback (NMManager *manager,
-                                const char *checkpoint_path,
-                                GCancellable *cancellable,
-                                GAsyncReadyCallback callback,
-                                gpointer user_data)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
-
-	simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                    nm_manager_checkpoint_rollback);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_manager_call_checkpoint_rollback (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                         checkpoint_path,
-	                                         cancellable,
-	                                         checkpoint_rollback_cb, simple);
-}
-
-GHashTable *
-nm_manager_checkpoint_rollback_finish (NMManager *manager,
-                                       GAsyncResult *result,
-                                       GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager),
-	                                                      nm_manager_checkpoint_rollback),
-	                      NULL);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return NULL;
-	else
-		return g_hash_table_ref (g_simple_async_result_get_op_res_gpointer (simple));
-}
-
-static void
-checkpoint_adjust_rollback_timeout_cb (GObject *object,
-                                       GAsyncResult *result,
-                                       gpointer user_data)
-{
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_manager_call_checkpoint_adjust_rollback_timeout_finish (NMDBUS_MANAGER (object),
-	                                                                   result,
-	                                                                   &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-}
-
-void
-nm_manager_checkpoint_adjust_rollback_timeout (NMManager *manager,
-                                               const char *checkpoint_path,
-                                               guint32 add_timeout,
-                                               GCancellable *cancellable,
-                                               GAsyncReadyCallback callback,
-                                               gpointer user_data)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-	g_return_if_fail (checkpoint_path && checkpoint_path[0] == '/');
-
-	simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                    nm_manager_checkpoint_adjust_rollback_timeout);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_manager_call_checkpoint_adjust_rollback_timeout (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                                                        checkpoint_path,
-	                                                        add_timeout,
-	                                                        cancellable,
-	                                                        checkpoint_adjust_rollback_timeout_cb,
-	                                                        simple);
-}
-
-gboolean
-nm_manager_checkpoint_adjust_rollback_timeout_finish (NMManager *manager,
-                                                      GAsyncResult *result,
-                                                      GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager),
-	                                                      nm_manager_checkpoint_adjust_rollback_timeout),
-	                      FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	return !g_simple_async_result_propagate_error (simple, error);
-}
-
-static void
-reload_cb (GObject *object,
-           GAsyncResult *result,
-           gpointer user_data)
-{
-	gs_unref_object GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_manager_call_reload_finish (NMDBUS_MANAGER (object),
-	                                       result,
-	                                       &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-}
-
-void
-nm_manager_reload (NMManager *manager,
-                   NMManagerReloadFlags flags,
-                   GCancellable *cancellable,
-                   GAsyncReadyCallback callback,
-                   gpointer user_data)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_MANAGER (manager));
-
-	simple = g_simple_async_result_new (G_OBJECT (manager), callback, user_data,
-	                                    nm_manager_reload);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_manager_call_reload (NM_MANAGER_GET_PRIVATE (manager)->proxy,
-	                            flags,
-	                            cancellable,
-	                            reload_cb,
-	                            simple);
-
-}
-
-gboolean
-nm_manager_reload_finish (NMManager *manager,
-                          GAsyncResult *result,
-                          GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (manager),
-	                                                      nm_manager_reload),
-	                      FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	return !g_simple_async_result_propagate_error (simple, error);
 }
 
 /*****************************************************************************/
@@ -1737,24 +1091,35 @@ static gboolean
 init_sync (GInitable *initable, GCancellable *cancellable, GError **error)
 {
 	NMManager *self = NM_MANAGER (initable);
-	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (self);
-	gs_free_error GError *local_error = NULL;
 	gs_unref_variant GVariant *permissions = NULL;
+	const char *name_owner;
 
-	if (!nm_manager_parent_initable_iface->init (initable, cancellable, error)) {
-		/* Never happens. */
+	if (!nm_manager_parent_initable_iface->init (initable, cancellable, error))
 		g_return_val_if_reached (FALSE);
-	}
 
-	if (!nmdbus_manager_call_get_permissions_sync (priv->proxy,
-	                                               &permissions,
-	                                               NULL,
-	                                               &local_error)) {
-		g_dbus_error_strip_remote_error (local_error);
-		g_warning ("Unable to get permissions: %s\n", local_error->message);
-	}
+	name_owner = _nm_object_get_dbus_name_owner (self);
+	if (name_owner) {
+		gs_unref_variant GVariant *ret = NULL;
 
+		ret = g_dbus_connection_call_sync (_nm_object_get_dbus_connection (self),
+		                                   name_owner,
+		                                   NM_DBUS_PATH,
+		                                   NM_DBUS_INTERFACE,
+		                                   "GetPermissions",
+		                                   g_variant_new ("()"),
+		                                   G_VARIANT_TYPE ("(a{ss})"),
+		                                   G_DBUS_CALL_FLAGS_NONE,
+		                                   NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+		                                   cancellable,
+		                                   NULL);
+		if (ret) {
+			g_variant_get (ret,
+			               "(@a{ss})",
+			               &permissions);
+		}
+	}
 	update_permissions (self, permissions);
+
 	return TRUE;
 }
 
@@ -1773,28 +1138,10 @@ init_async_complete (NMManagerInitData *init_data)
 	g_slice_free (NMManagerInitData, init_data);
 }
 
-static void
-init_async_got_permissions (GObject *object, GAsyncResult *result, gpointer user_data)
-{
-	NMManager *manager = user_data;
-	GVariant *permissions;
-
-	if (nmdbus_manager_call_get_permissions_finish (NMDBUS_MANAGER (object),
-	                                                &permissions,
-	                                                result, NULL)) {
-		update_permissions (manager, permissions);
-		g_variant_unref (permissions);
-	} else
-		update_permissions (manager, NULL);
-
-	g_object_unref (manager);
-}
-
 static void
 init_async_parent_inited (GObject *source, GAsyncResult *result, gpointer user_data)
 {
 	NMManagerInitData *init_data = user_data;
-	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (init_data->manager);
 	GError *error = NULL;
 
 	if (!nm_manager_parent_async_initable_iface->init_finish (G_ASYNC_INITABLE (source), result, &error)) {
@@ -1803,10 +1150,7 @@ init_async_parent_inited (GObject *source, GAsyncResult *result, gpointer user_d
 		return;
 	}
 
-	nmdbus_manager_call_get_permissions (priv->proxy,
-	                                     init_data->cancellable,
-	                                     init_async_got_permissions,
-	                                     g_object_ref (init_data->manager));
+	manager_recheck_permissions (NULL, init_data->manager);
 
 	init_async_complete (init_data);
 }
@@ -1848,6 +1192,9 @@ dispose (GObject *object)
 	NMManager *manager = NM_MANAGER (object);
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (object);
 
+	nm_assert (c_list_is_empty (&priv->wait_for_active_connection_lst_head));
+	nm_assert (c_list_is_empty (&priv->wait_for_checkpoint_lst_head));
+
 	nm_clear_g_cancellable (&priv->perm_call_cancellable);
 
 	if (priv->devices) {
@@ -1867,11 +1214,6 @@ dispose (GObject *object)
 
 	g_clear_object (&priv->proxy);
 
-	/* Each activation should hold a ref on @manager, so if we're being disposed,
-	 * there shouldn't be any pending.
-	 */
-	g_warn_if_fail (c_list_is_empty (&priv->pending_activations));
-
 	g_hash_table_destroy (priv->permissions);
 	priv->permissions = NULL;
 
@@ -1894,12 +1236,18 @@ set_property (GObject *object, guint prop_id,
 {
 	NMManagerPrivate *priv = NM_MANAGER_GET_PRIVATE (object);
 	gboolean b;
+	const char *name_owner;
 
 	switch (prop_id) {
 	case PROP_NETWORKING_ENABLED:
 		b = g_value_get_boolean (value);
 		if (priv->networking_enabled != b) {
-			nm_manager_networking_set_enabled (NM_MANAGER (object), b, NULL);
+			if ((name_owner = _nm_object_get_dbus_name_owner (object))) {
+				_nm_manager_networking_set_enabled (_nm_object_get_dbus_connection (object),
+				                                    name_owner,
+				                                    b,
+				                                    NULL);
+			}
 			/* Let the property value flip when we get the change signal from NM */
 		}
 		break;
diff --git a/libnm/nm-manager.h b/libnm/nm-manager.h
index 9b46b6417d..50b6215b0c 100644
--- a/libnm/nm-manager.h
+++ b/libnm/nm-manager.h
@@ -84,8 +84,9 @@ gboolean  nm_manager_get_startup          (NMManager *manager);
 gboolean  nm_manager_networking_get_enabled (NMManager *manager);
 
 _NM_DEPRECATED_SYNC_METHOD_INTERNAL
-gboolean  nm_manager_networking_set_enabled (NMManager *manager,
-                                             gboolean enabled,
+gboolean _nm_manager_networking_set_enabled (GDBusConnection *dbus_connection,
+                                             const char *name_owner,
+                                             gboolean enable,
                                              GError **error);
 
 gboolean  nm_manager_wireless_get_enabled (NMManager *manager);
@@ -112,31 +113,13 @@ void      nm_manager_connectivity_check_set_enabled (NMManager *manager,
 
 const char *nm_manager_connectivity_check_get_uri (NMManager *manager);
 
-gboolean nm_manager_get_logging (NMManager *manager,
-                                 char **level,
-                                 char **domains,
-                                 GError **error);
-gboolean nm_manager_set_logging (NMManager *manager,
-                                 const char *level,
-                                 const char *domains,
-                                 GError **error);
-
 NMClientPermissionResult nm_manager_get_permission_result (NMManager *manager,
                                                            NMClientPermission permission);
 
 NMConnectivityState nm_manager_get_connectivity          (NMManager *manager);
 
-_NM_DEPRECATED_SYNC_METHOD_INTERNAL
-NMConnectivityState nm_manager_check_connectivity        (NMManager *manager,
-                                                          GCancellable *cancellable,
-                                                          GError **error);
-void                nm_manager_check_connectivity_async  (NMManager *manager,
-                                                          GCancellable *cancellable,
-                                                          GAsyncReadyCallback callback,
-                                                          gpointer user_data);
-NMConnectivityState nm_manager_check_connectivity_finish (NMManager *manager,
-                                                          GAsyncResult *result,
-                                                          GError **error);
+void _nm_manager_set_connectivity_hack (NMManager *manager,
+                                        guint32 connectivity);
 
 /* Devices */
 
@@ -152,81 +135,17 @@ const GPtrArray *nm_manager_get_active_connections (NMManager *manager);
 NMActiveConnection *nm_manager_get_primary_connection (NMManager *manager);
 NMActiveConnection *nm_manager_get_activating_connection (NMManager *manager);
 
-void                nm_manager_activate_connection_async  (NMManager *manager,
-                                                           NMConnection *connection,
-                                                           NMDevice *device,
-                                                           const char *specific_object,
-                                                           GCancellable *cancellable,
-                                                           GAsyncReadyCallback callback,
-                                                           gpointer user_data);
-NMActiveConnection *nm_manager_activate_connection_finish (NMManager *manager,
-                                                           GAsyncResult *result,
-                                                           GError **error);
-
-void                nm_manager_add_and_activate_connection_async  (NMManager *manager,
-                                                                   NMConnection *partial,
-                                                                   NMDevice *device,
-                                                                   const char *specific_object,
-                                                                   GVariant *options,
-                                                                   gboolean force_v2,
-                                                                   GCancellable *cancellable,
-                                                                   GAsyncReadyCallback callback,
-                                                                   gpointer user_data);
-NMActiveConnection *nm_manager_add_and_activate_connection_finish (NMManager *manager,
-                                                                   GAsyncResult *result,
-                                                                   GVariant **out_result,
-                                                                   GError **error);
-
-_NM_DEPRECATED_SYNC_METHOD_INTERNAL
-gboolean nm_manager_deactivate_connection        (NMManager *manager,
-                                                  NMActiveConnection *active,
-                                                  GCancellable *cancellable,
-                                                  GError **error);
-void     nm_manager_deactivate_connection_async  (NMManager *manager,
-                                                  NMActiveConnection *active,
-                                                  GCancellable *cancellable,
-                                                  GAsyncReadyCallback callback,
-                                                  gpointer user_data);
-gboolean nm_manager_deactivate_connection_finish (NMManager *manager,
-                                                  GAsyncResult *result,
-                                                  GError **error);
+void nm_manager_wait_for_active_connection (NMManager *self,
+                                            const char *active_path,
+                                            const char *connection_path,
+                                            GVariant *add_and_activate_output_take,
+                                            GTask *task_take);
 
 const GPtrArray *nm_manager_get_checkpoints (NMManager *manager);
-void nm_manager_checkpoint_create (NMManager *manager,
-                                   const GPtrArray *devices,
-                                   guint32 rollback_timeout,
-                                   NMCheckpointCreateFlags flags,
-                                   GCancellable *cancellable,
-                                   GAsyncReadyCallback callback,
-                                   gpointer user_data);
-NMCheckpoint *nm_manager_checkpoint_create_finish (NMManager *manager,
-                                                   GAsyncResult *result,
-                                                   GError **error);
-void nm_manager_checkpoint_destroy (NMManager *manager,
-                                    const char *checkpoint_path,
-                                    GCancellable *cancellable,
-                                    GAsyncReadyCallback callback,
-                                    gpointer user_data);
-gboolean nm_manager_checkpoint_destroy_finish (NMManager *manager,
-                                               GAsyncResult *result,
-                                               GError **error);
-void nm_manager_checkpoint_rollback (NMManager *manager,
+
+void nm_manager_wait_for_checkpoint (NMManager *self,
                                      const char *checkpoint_path,
-                                     GCancellable *cancellable,
-                                     GAsyncReadyCallback callback,
-                                     gpointer user_data);
-GHashTable *nm_manager_checkpoint_rollback_finish (NMManager *manager,
-                                                   GAsyncResult *result,
-                                                   GError **error);
-void nm_manager_checkpoint_adjust_rollback_timeout (NMManager *manager,
-                                                    const char *checkpoint_path,
-                                                    guint32 add_timeout,
-                                                    GCancellable *cancellable,
-                                                    GAsyncReadyCallback callback,
-                                                    gpointer user_data);
-gboolean nm_manager_checkpoint_adjust_rollback_timeout_finish (NMManager *manager,
-                                                               GAsyncResult *result,
-                                                               GError **error);
+                                     GTask *task_take);
 
 /*****************************************************************************/
 
@@ -240,15 +159,9 @@ _NMActivateResult *_nm_activate_result_new (NMActiveConnection *active,
 
 void _nm_activate_result_free (_NMActivateResult *result);
 
+NM_AUTO_DEFINE_FCN0 (_NMActivateResult *, _nm_auto_free_activate_result, _nm_activate_result_free)
+#define nm_auto_free_activate_result nm_auto(_nm_auto_free_activate_result)
+
 /*****************************************************************************/
 
-void nm_manager_reload (NMManager *manager,
-                        NMManagerReloadFlags flags,
-                        GCancellable *cancellable,
-                        GAsyncReadyCallback callback,
-                        gpointer user_data);
-gboolean nm_manager_reload_finish (NMManager *manager,
-                                   GAsyncResult *result,
-                                   GError **error);
-
 #endif /* __NM_MANAGER_H__ */
diff --git a/libnm/nm-object-private.h b/libnm/nm-object-private.h
index eb9e0f1407..863b228fae 100644
--- a/libnm/nm-object-private.h
+++ b/libnm/nm-object-private.h
@@ -34,7 +34,50 @@ GDBusObjectManager *_nm_object_get_dbus_object_manager (NMObject *object);
 
 GQuark _nm_object_obj_nm_quark (void);
 
-/* DBus property accessors */
+GDBusConnection *_nm_object_get_dbus_connection (gpointer self);
+
+const char *_nm_object_get_dbus_name_owner (gpointer self);
+
+GDBusConnection *_nm_client_get_dbus_connection (NMClient *client);
+
+const char *_nm_client_get_dbus_name_owner (NMClient *client);
+
+void _nm_object_dbus_call (gpointer self,
+                           gpointer source_tag,
+                           GCancellable *cancellable,
+                           GAsyncReadyCallback user_callback,
+                           gpointer user_callback_data,
+                           const char *object_path,
+                           const char *interface_name,
+                           const char *method_name,
+                           GVariant *parameters,
+                           const GVariantType *reply_type,
+                           GDBusCallFlags flags,
+                           int timeout_msec,
+                           GAsyncReadyCallback internal_callback);
+
+GVariant *_nm_object_dbus_call_sync (gpointer self,
+                                     GCancellable *cancellable,
+                                     const char *object_path,
+                                     const char *interface_name,
+                                     const char *method_name,
+                                     GVariant *parameters,
+                                     const GVariantType *reply_type,
+                                     GDBusCallFlags flags,
+                                     int timeout_msec,
+                                     gboolean strip_dbus_error,
+                                     GError **error);
+
+gboolean _nm_object_dbus_call_sync_void (gpointer self,
+                                         GCancellable *cancellable,
+                                         const char *object_path,
+                                         const char *interface_name,
+                                         const char *method_name,
+                                         GVariant *parameters,
+                                         GDBusCallFlags flags,
+                                         int timeout_msec,
+                                         gboolean strip_dbus_error,
+                                         GError **error);
 
 void _nm_object_set_property (NMObject *object,
                               const char *interface,
@@ -45,6 +88,9 @@ void _nm_object_set_property (NMObject *object,
 GDBusProxy *_nm_object_get_proxy (NMObject   *object,
                                   const char *interface);
 
+GError *_nm_object_new_error_nm_not_running (void);
+void _nm_object_set_error_nm_not_running (GError **error);
+
 struct udev;
 void _nm_device_set_udev (NMDevice *device, struct udev *udev);
 
diff --git a/libnm/nm-object.c b/libnm/nm-object.c
index 8c91e7a38e..bbe97eb6cd 100644
--- a/libnm/nm-object.c
+++ b/libnm/nm-object.c
@@ -69,6 +69,8 @@ typedef struct {
 
 	CList pending;          /* ordered list of pending property updates. */
 	GPtrArray *proxies;
+
+	char *name_owner_cached;
 } NMObjectPrivate;
 
 enum {
@@ -127,6 +129,211 @@ _nm_object_get_proxy (NMObject   *object,
 	return G_DBUS_PROXY (proxy);
 }
 
+/*****************************************************************************/
+
+GDBusConnection *
+_nm_object_get_dbus_connection (gpointer self)
+{
+	NMObjectPrivate *priv;
+
+	nm_assert (NM_IS_OBJECT (self));
+
+	priv = NM_OBJECT_GET_PRIVATE (self);
+
+	return g_dbus_object_manager_client_get_connection (G_DBUS_OBJECT_MANAGER_CLIENT (priv->object_manager));
+}
+
+const char *
+_nm_object_get_dbus_name_owner (gpointer self)
+{
+	NMObjectPrivate *priv;
+
+	nm_assert (NM_IS_OBJECT (self));
+
+	priv = NM_OBJECT_GET_PRIVATE (self);
+
+	nm_clear_g_free (&priv->name_owner_cached);
+	priv->name_owner_cached = g_dbus_object_manager_client_get_name_owner (G_DBUS_OBJECT_MANAGER_CLIENT (priv->object_manager));
+	return priv->name_owner_cached;
+}
+
+static gboolean
+_get_dbus_params (gpointer self,
+                  GDBusConnection **out_dbus_connection,
+                  const char **out_name_owner)
+{
+	const char *name_owner;
+	GDBusConnection *dbus_connection = NULL;
+
+	if (NM_IS_OBJECT (self)) {
+		name_owner = _nm_object_get_dbus_name_owner (self);
+		if (name_owner)
+			dbus_connection = _nm_object_get_dbus_connection (self);
+	} else {
+		nm_assert (NM_IS_CLIENT (self));
+		name_owner = _nm_client_get_dbus_name_owner (self);
+		if (name_owner)
+			dbus_connection = _nm_client_get_dbus_connection (self);
+	}
+
+	*out_dbus_connection = dbus_connection;
+	*out_name_owner = name_owner;
+	return !!name_owner;
+}
+
+void
+_nm_object_dbus_call (gpointer self,
+                      gpointer source_tag,
+                      GCancellable *cancellable,
+                      GAsyncReadyCallback user_callback,
+                      gpointer user_callback_data,
+                      const char *object_path,
+                      const char *interface_name,
+                      const char *method_name,
+                      GVariant *parameters,
+                      const GVariantType *reply_type,
+                      GDBusCallFlags flags,
+                      int timeout_msec,
+                      GAsyncReadyCallback internal_callback)
+{
+	gs_unref_object GTask *task = NULL;
+	const char *name_owner;
+	GDBusConnection *dbus_connection;
+
+	nm_assert (G_IS_OBJECT (self));
+	nm_assert (source_tag);
+	nm_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+	nm_assert (internal_callback);
+	nm_assert (object_path);
+	nm_assert (interface_name);
+	nm_assert (method_name);
+	nm_assert (parameters);
+	nm_assert (reply_type);
+
+	task = nm_g_task_new (self, cancellable, source_tag, user_callback, user_callback_data);
+
+	if (!_get_dbus_params (self, &dbus_connection, &name_owner)) {
+		nm_g_variant_unref_floating (parameters);
+		g_task_return_error (task, _nm_object_new_error_nm_not_running ());
+		return;
+	}
+
+	g_dbus_connection_call (dbus_connection,
+	                        name_owner,
+	                        object_path,
+	                        interface_name,
+	                        method_name,
+	                        parameters,
+	                        reply_type,
+	                        flags,
+	                        timeout_msec,
+	                        cancellable,
+	                        internal_callback,
+	                        g_steal_pointer (&task));
+}
+
+GVariant *
+_nm_object_dbus_call_sync (gpointer self,
+                           GCancellable *cancellable,
+                           const char *object_path,
+                           const char *interface_name,
+                           const char *method_name,
+                           GVariant *parameters,
+                           const GVariantType *reply_type,
+                           GDBusCallFlags flags,
+                           int timeout_msec,
+                           gboolean strip_dbus_error,
+                           GError **error)
+{
+	gs_unref_variant GVariant *ret = NULL;
+	GDBusConnection *dbus_connection;
+	const char *name_owner;
+
+	nm_assert (G_IS_OBJECT (self));
+	nm_assert (!cancellable || G_IS_CANCELLABLE (cancellable));
+	nm_assert (!error || !*error);
+	nm_assert (object_path);
+	nm_assert (interface_name);
+	nm_assert (method_name);
+	nm_assert (parameters);
+	nm_assert (reply_type);
+
+	if (!_get_dbus_params (self, &dbus_connection, &name_owner)) {
+		nm_g_variant_unref_floating (parameters);
+		_nm_object_set_error_nm_not_running (error);
+		return NULL;
+	}
+
+	ret = g_dbus_connection_call_sync (dbus_connection,
+	                                   name_owner,
+	                                   object_path,
+	                                   interface_name,
+	                                   method_name,
+	                                   parameters,
+	                                   reply_type,
+	                                   flags,
+	                                   timeout_msec,
+	                                   cancellable,
+	                                   error);
+	if (!ret) {
+		if (error && strip_dbus_error)
+			g_dbus_error_strip_remote_error (*error);
+		return NULL;
+	}
+
+	return g_steal_pointer (&ret);
+}
+
+gboolean
+_nm_object_dbus_call_sync_void (gpointer self,
+                                GCancellable *cancellable,
+                                const char *object_path,
+                                const char *interface_name,
+                                const char *method_name,
+                                GVariant *parameters,
+                                GDBusCallFlags flags,
+                                int timeout_msec,
+                                gboolean strip_dbus_error,
+                                GError **error)
+{
+	gs_unref_variant GVariant *ret = NULL;
+
+	ret = _nm_object_dbus_call_sync (self,
+	                                 cancellable,
+	                                 object_path,
+	                                 interface_name,
+	                                 method_name,
+	                                 parameters,
+	                                 G_VARIANT_TYPE ("()"),
+	                                 flags,
+	                                 timeout_msec,
+	                                 strip_dbus_error,
+	                                 error);
+	return !!ret;
+}
+
+/*****************************************************************************/
+
+GError *
+_nm_object_new_error_nm_not_running (void)
+{
+	return g_error_new_literal (NM_CLIENT_ERROR,
+	                            NM_CLIENT_ERROR_MANAGER_NOT_RUNNING,
+	                            "NetworkManager is not running");
+}
+
+void
+_nm_object_set_error_nm_not_running (GError **error)
+{
+	if (error) {
+		if (*error)
+			g_return_if_reached ();
+		*error = _nm_object_new_error_nm_not_running ();
+	}
+}
+
+/*****************************************************************************/
+
 typedef enum {
 	NOTIFY_SIGNAL_PENDING_NONE,
 	NOTIFY_SIGNAL_PENDING_ADDED,
@@ -1251,6 +1458,8 @@ finalize (GObject *object)
 
 	g_slist_free_full (priv->property_tables, (GDestroyNotify) g_hash_table_destroy);
 
+	g_free (priv->name_owner_cached);
+
 	G_OBJECT_CLASS (nm_object_parent_class)->finalize (object);
 }
 
diff --git a/libnm/nm-remote-connection.c b/libnm/nm-remote-connection.c
index 04fbd3b170..4fd7146891 100644
--- a/libnm/nm-remote-connection.c
+++ b/libnm/nm-remote-connection.c
@@ -8,6 +8,7 @@
 
 #include "nm-remote-connection.h"
 
+#include "nm-glib-aux/nm-dbus-aux.h"
 #include "nm-dbus-interface.h"
 #include "nm-utils.h"
 #include "nm-setting-connection.h"
@@ -62,28 +63,6 @@ typedef struct {
 
 /*****************************************************************************/
 
-static void
-update2_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-	GVariant *v;
-
-	if (nmdbus_settings_connection_call_update2_finish (NMDBUS_SETTINGS_CONNECTION (proxy),
-	                                                    &v,
-	                                                    result,
-	                                                    &error)) {
-		g_simple_async_result_set_op_res_gpointer (simple,
-		                                           v,
-		                                           (GDestroyNotify) g_variant_unref);
-	} else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
 /**
  * nm_remote_connection_update2:
  * @connection: the #NMRemoteConnection
@@ -107,37 +86,32 @@ nm_remote_connection_update2 (NMRemoteConnection *connection,
                               GAsyncReadyCallback callback,
                               gpointer user_data)
 {
-	NMRemoteConnectionPrivate *priv;
-	GSimpleAsyncResult *simple;
-	GVariantBuilder builder;
-
 	g_return_if_fail (NM_IS_REMOTE_CONNECTION (connection));
 	g_return_if_fail (!settings || g_variant_is_of_type (settings, NM_VARIANT_TYPE_CONNECTION));
 	g_return_if_fail (!args || g_variant_is_of_type (args, G_VARIANT_TYPE ("a{sv}")));
 	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
+	if (!settings)
+		settings = g_variant_new_array (G_VARIANT_TYPE ("{sa{sv}}"), NULL, 0);
+	if (!args)
+		args = g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0);
 
-	simple = g_simple_async_result_new (G_OBJECT (connection), callback, user_data,
-	                                    nm_remote_connection_update2);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	if (!settings) {
-		g_variant_builder_init (&builder, NM_VARIANT_TYPE_CONNECTION);
-		settings = g_variant_builder_end (&builder);
-	}
-	if (!args) {
-		g_variant_builder_init (&builder, G_VARIANT_TYPE ("a{sv}"));
-		args = g_variant_builder_end (&builder);
-	}
-	nmdbus_settings_connection_call_update2 (priv->proxy,
-	                                         settings,
-	                                         flags,
-	                                         args,
-	                                         cancellable,
-	                                         update2_cb,
-	                                         simple);
+	_nm_object_dbus_call (connection,
+	                      nm_remote_connection_update2,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                      NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                      "Update2",
+	                      g_variant_new ("(@a{sa{sv}}u@a{sv})",
+	                                     settings,
+	                                     (guint32) flags,
+	                                     args),
+	                      G_VARIANT_TYPE ("(a{sv})"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -148,7 +122,7 @@ nm_remote_connection_update2 (NMRemoteConnection *connection,
  *
  * Gets the result of a call to nm_remote_connection_commit_changes_async().
  *
- * Returns: on success, a #GVariant of type "a{sv}" with the result. On failure,
+ * Returns: (transfer full): on success, a #GVariant of type "a{sv}" with the result. On failure,
  *   %NULL.
  **/
 GVariant *
@@ -156,15 +130,21 @@ nm_remote_connection_update2_finish (NMRemoteConnection *connection,
                                      GAsyncResult *result,
                                      GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *ret = NULL;
+	GVariant *v_result;
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (connection), nm_remote_connection_update2), FALSE);
+	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, connection, nm_remote_connection_update2), NULL);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret)
 		return NULL;
-	else
-		return g_variant_ref (g_simple_async_result_get_op_res_gpointer (simple));
+
+	g_variant_get (ret,
+	               "(@a{sv})",
+	               &v_result);
+
+	return v_result;
 }
 
 /*****************************************************************************/
@@ -190,49 +170,32 @@ nm_remote_connection_commit_changes (NMRemoteConnection *connection,
                                      GCancellable *cancellable,
                                      GError **error)
 {
-	NMRemoteConnectionPrivate *priv;
-	gs_unref_variant GVariant *result = NULL;
-	gboolean ret;
-	GVariantBuilder args;
+	gs_unref_variant GVariant *ret = NULL;
 
 	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
+	ret = _nm_object_dbus_call_sync (connection,
+	                                 cancellable,
+	                                 g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                                 NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                                 "Update2",
+	                                 g_variant_new ("(@a{sa{sv}}u@a{sv})",
+	                                                nm_connection_to_dbus (NM_CONNECTION (connection),
+	                                                                       NM_CONNECTION_SERIALIZE_ALL),
+	                                                (guint32) (  save_to_disk
+	                                                           ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK
+	                                                           : NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY),
+	                                                g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0)),
+	                                 G_VARIANT_TYPE ("(a{sv})"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret)
+		return FALSE;
 
-	g_variant_builder_init (&args, G_VARIANT_TYPE ("a{sv}"));
-	ret = nmdbus_settings_connection_call_update2_sync (priv->proxy,
-	                                                    nm_connection_to_dbus (NM_CONNECTION (connection),
-	                                                                           NM_CONNECTION_SERIALIZE_ALL),
-	                                                    save_to_disk
-	                                                      ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK
-	                                                      : NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY,
-	                                                    g_variant_builder_end (&args),
-	                                                    &result,
-	                                                    cancellable,
-	                                                    error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-update_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-	gs_unref_variant GVariant *v = NULL;
-
-	if (nmdbus_settings_connection_call_update2_finish (NMDBUS_SETTINGS_CONNECTION (proxy),
-	                                                    &v,
-	                                                    result,
-	                                                    &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return TRUE;
 }
 
 /**
@@ -255,30 +218,19 @@ nm_remote_connection_commit_changes_async (NMRemoteConnection *connection,
                                            GAsyncReadyCallback callback,
                                            gpointer user_data)
 {
-	NMRemoteConnectionPrivate *priv;
-	GSimpleAsyncResult *simple;
-	GVariantBuilder args;
-
 	g_return_if_fail (NM_IS_REMOTE_CONNECTION (connection));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	simple = g_simple_async_result_new (G_OBJECT (connection), callback, user_data,
-	                                    nm_remote_connection_commit_changes_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	g_variant_builder_init (&args, G_VARIANT_TYPE ("a{sv}"));
-	nmdbus_settings_connection_call_update2 (priv->proxy,
-	                                         nm_connection_to_dbus (NM_CONNECTION (connection),
-	                                                                NM_CONNECTION_SERIALIZE_ALL),
-	                                         save_to_disk
-	                                           ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK
-	                                           : NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY,
-	                                         g_variant_builder_end (&args),
-	                                         cancellable,
-	                                         update_cb,
-	                                         simple);
+	nm_remote_connection_update2 (connection,
+	                              nm_connection_to_dbus (NM_CONNECTION (connection),
+	                                                     NM_CONNECTION_SERIALIZE_ALL),
+	                                save_to_disk
+	                              ? NM_SETTINGS_UPDATE2_FLAG_TO_DISK
+	                              : NM_SETTINGS_UPDATE2_FLAG_IN_MEMORY,
+	                              NULL,
+	                              cancellable,
+	                              callback,
+	                              user_data);
 }
 
 /**
@@ -296,15 +248,10 @@ nm_remote_connection_commit_changes_finish (NMRemoteConnection *connection,
                                             GAsyncResult *result,
                                             GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *v_result = NULL;
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (connection), nm_remote_connection_commit_changes_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	v_result = nm_remote_connection_update2_finish (connection, result, error);
+	return !!v_result;
 }
 
 /*****************************************************************************/
@@ -327,34 +274,19 @@ nm_remote_connection_save (NMRemoteConnection *connection,
                            GCancellable *cancellable,
                            GError **error)
 {
-	NMRemoteConnectionPrivate *priv;
-	gboolean ret;
-
 	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), FALSE);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), FALSE);
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	ret = nmdbus_settings_connection_call_save_sync (priv->proxy, cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-save_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_settings_connection_call_save_finish (NMDBUS_SETTINGS_CONNECTION (proxy),
-	                                                 result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (connection,
+	                                       cancellable,
+	                                       g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                                       NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                                       "Save",
+	                                       g_variant_new ("()"),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -373,18 +305,22 @@ nm_remote_connection_save_async (NMRemoteConnection *connection,
                                  GAsyncReadyCallback callback,
                                  gpointer user_data)
 {
-	NMRemoteConnectionPrivate *priv;
-	GSimpleAsyncResult *simple;
-
 	g_return_if_fail (NM_IS_REMOTE_CONNECTION (connection));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	simple = g_simple_async_result_new (G_OBJECT (connection), callback, user_data,
-	                                    nm_remote_connection_save_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nmdbus_settings_connection_call_save (priv->proxy, cancellable, save_cb, simple);
+	_nm_object_dbus_call (connection,
+	                      nm_remote_connection_save_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                      NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                      "Save",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -402,15 +338,10 @@ nm_remote_connection_save_finish (NMRemoteConnection *connection,
                                   GAsyncResult *result,
                                   GError **error)
 {
-	GSimpleAsyncResult *simple;
+	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, connection, nm_remote_connection_save_async), FALSE);
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (connection), nm_remote_connection_save_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /*****************************************************************************/
@@ -432,34 +363,18 @@ nm_remote_connection_delete (NMRemoteConnection *connection,
                              GCancellable *cancellable,
                              GError **error)
 {
-	NMRemoteConnectionPrivate *priv;
-	gboolean ret;
-
 	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), FALSE);
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	ret = nmdbus_settings_connection_call_delete_sync (priv->proxy, cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-delete_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_settings_connection_call_delete_finish (NMDBUS_SETTINGS_CONNECTION (proxy),
-	                                                   result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return _nm_object_dbus_call_sync_void (connection,
+	                                       cancellable,
+	                                       g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                                       NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                                       "Delete",
+	                                       g_variant_new ("()"),
+	                                       G_DBUS_CALL_FLAGS_NONE,
+	                                       NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                       TRUE,
+	                                       error);
 }
 
 /**
@@ -477,18 +392,22 @@ nm_remote_connection_delete_async (NMRemoteConnection *connection,
                                    GAsyncReadyCallback callback,
                                    gpointer user_data)
 {
-	NMRemoteConnectionPrivate *priv;
-	GSimpleAsyncResult *simple;
-
 	g_return_if_fail (NM_IS_REMOTE_CONNECTION (connection));
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	simple = g_simple_async_result_new (G_OBJECT (connection), callback, user_data,
-	                                    nm_remote_connection_delete_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-	nmdbus_settings_connection_call_delete (priv->proxy, cancellable, delete_cb, simple);
+	_nm_object_dbus_call (connection,
+	                      nm_remote_connection_delete_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                      NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                      "Delete",
+	                      g_variant_new ("()"),
+	                      G_VARIANT_TYPE ("()"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_void_strip_dbus_error_cb);
 }
 
 /**
@@ -506,15 +425,10 @@ nm_remote_connection_delete_finish (NMRemoteConnection *connection,
                                     GAsyncResult *result,
                                     GError **error)
 {
-	GSimpleAsyncResult *simple;
+	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), FALSE);
+	g_return_val_if_fail (nm_g_task_is_valid (result, connection, nm_remote_connection_delete_async), FALSE);
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (connection), nm_remote_connection_delete_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	return g_task_propagate_boolean (G_TASK (result), error);
 }
 
 /**
@@ -527,7 +441,7 @@ nm_remote_connection_delete_finish (NMRemoteConnection *connection,
  * Request the connection's secrets. Note that this is a blocking D-Bus call,
  * not a simple property accessor.
  *
- * Returns: a #GVariant of type %NM_VARIANT_TYPE_CONNECTION containing
+ * Returns: (transfer full): a #GVariant of type %NM_VARIANT_TYPE_CONNECTION containing
  * @connection's secrets, or %NULL on error.
  *
  * Deprecated: 1.22, use nm_remote_connection_get_secrets_async() or GDBusConnection
@@ -538,42 +452,32 @@ nm_remote_connection_get_secrets (NMRemoteConnection *connection,
                                   GCancellable *cancellable,
                                   GError **error)
 {
-	NMRemoteConnectionPrivate *priv;
+	gs_unref_variant GVariant *ret = NULL;
 	GVariant *secrets;
 
 	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), NULL);
+	g_return_val_if_fail (setting_name, NULL);
+	g_return_val_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable), NULL);
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	if (nmdbus_settings_connection_call_get_secrets_sync (priv->proxy,
-	                                                      setting_name,
-	                                                      &secrets,
-	                                                      cancellable, error))
-		return secrets;
-	else {
-		if (error && *error)
-			g_dbus_error_strip_remote_error (*error);
+	ret = _nm_object_dbus_call_sync (connection,
+	                                 cancellable,
+	                                 g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                                 NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                                 "GetSecrets",
+	                                 g_variant_new ("(s)", setting_name),
+	                                 G_VARIANT_TYPE ("(a{sa{sv}})"),
+	                                 G_DBUS_CALL_FLAGS_NONE,
+	                                 NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                                 TRUE,
+	                                 error);
+	if (!ret)
 		return NULL;
-	}
-}
 
-static void
-get_secrets_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GVariant *secrets = NULL;
-	GError *error = NULL;
+	g_variant_get (ret,
+	               "(@a{sa{sv}})",
+	               &secrets);
 
-	if (nmdbus_settings_connection_call_get_secrets_finish (NMDBUS_SETTINGS_CONNECTION (proxy),
-	                                                        &secrets, result, &error))
-		g_simple_async_result_set_op_res_gpointer (simple, secrets, (GDestroyNotify) g_variant_unref);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
+	return secrets;
 }
 
 /**
@@ -593,22 +497,23 @@ nm_remote_connection_get_secrets_async (NMRemoteConnection *connection,
                                         GAsyncReadyCallback callback,
                                         gpointer user_data)
 {
-	NMRemoteConnectionPrivate *priv;
-	GSimpleAsyncResult *simple;
-
 	g_return_if_fail (NM_IS_REMOTE_CONNECTION (connection));
+	g_return_if_fail (setting_name);
+	g_return_if_fail (!cancellable || G_IS_CANCELLABLE (cancellable));
 
-	priv = NM_REMOTE_CONNECTION_GET_PRIVATE (connection);
-
-	simple = g_simple_async_result_new (G_OBJECT (connection), callback, user_data,
-	                                    nm_remote_connection_get_secrets_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_settings_connection_call_get_secrets (priv->proxy,
-	                                             setting_name,
-	                                             cancellable,
-	                                             get_secrets_cb, simple);
+	_nm_object_dbus_call (connection,
+	                      nm_remote_connection_get_secrets_async,
+	                      cancellable,
+	                      callback,
+	                      user_data,
+	                      g_dbus_proxy_get_object_path (G_DBUS_PROXY (NM_REMOTE_CONNECTION_GET_PRIVATE (connection)->proxy)),
+	                      NM_DBUS_INTERFACE_SETTINGS_CONNECTION,
+	                      "GetSecrets",
+	                      g_variant_new ("(s)", setting_name),
+	                      G_VARIANT_TYPE ("(a{sa{sv}})"),
+	                      G_DBUS_CALL_FLAGS_NONE,
+	                      NM_DBUS_DEFAULT_TIMEOUT_MSEC,
+	                      nm_dbus_connection_call_finish_variant_strip_dbus_error_cb);
 }
 
 /**
@@ -627,15 +532,21 @@ nm_remote_connection_get_secrets_finish (NMRemoteConnection *connection,
                                          GAsyncResult *result,
                                          GError **error)
 {
-	GSimpleAsyncResult *simple;
+	gs_unref_variant GVariant *ret = NULL;
+	GVariant *secrets;
 
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (connection), nm_remote_connection_get_secrets_async), FALSE);
+	g_return_val_if_fail (NM_IS_REMOTE_CONNECTION (connection), NULL);
+	g_return_val_if_fail (nm_g_task_is_valid (result, connection, nm_remote_connection_get_secrets_async), FALSE);
 
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
+	ret = g_task_propagate_pointer (G_TASK (result), error);
+	if (!ret)
 		return NULL;
-	else
-		return g_variant_ref (g_simple_async_result_get_op_res_gpointer (simple));
+
+	g_variant_get (ret,
+	               "(@a{sa{sv}})",
+	               &secrets);
+
+	return secrets;
 }
 
 /**
diff --git a/libnm/nm-remote-settings.c b/libnm/nm-remote-settings.c
index 24abcee397..0a95ce3050 100644
--- a/libnm/nm-remote-settings.c
+++ b/libnm/nm-remote-settings.c
@@ -59,24 +59,20 @@ static guint signals[LAST_SIGNAL] = { 0 };
 typedef struct {
 	CList add_lst;
 	NMRemoteSettings *self;
-	NMRemoteSettingAddConnection2Callback callback;
-	gpointer user_data;
-	GCancellable *cancellable;
-	char *path;
-	GVariant *results;
+	GTask *task;
+	char *connection_path;
+	GVariant *extra_results;
 	gulong cancellable_id;
-	NMSettingsAddConnection2Flags flags;
-	bool ignore_out_result:1;
 } AddConnectionInfo;
 
 static AddConnectionInfo *
-_add_connection_info_find (NMRemoteSettings *self, const char *path)
+_add_connection_info_find (NMRemoteSettings *self, const char *connection_path)
 {
 	NMRemoteSettingsPrivate *priv = NM_REMOTE_SETTINGS_GET_PRIVATE (self);
 	AddConnectionInfo *info;
 
 	c_list_for_each_entry (info, &priv->add_lst_head, add_lst) {
-		if (nm_streq0 (info->path, path))
+		if (nm_streq (info->connection_path, connection_path))
 			return info;
 	}
 	return NULL;
@@ -91,38 +87,31 @@ _add_connection_info_complete (AddConnectionInfo *info,
 
 	c_list_unlink_stale (&info->add_lst);
 
-	nm_clear_g_signal_handler (info->cancellable, &info->cancellable_id);
+	nm_clear_g_signal_handler (g_task_get_cancellable (info->task), &info->cancellable_id);
 
-	if (   info->cancellable
-	    && !nm_utils_error_is_cancelled (error_take, FALSE)) {
-		GError *error2 = NULL;
+	if (error_take)
+		g_task_return_error (info->task, error_take);
+	else {
+		NMAddConnectionResultData *result_info;
 
-		if (g_cancellable_set_error_if_cancelled (info->cancellable, &error2)) {
-			g_clear_error (&error_take);
-			error_take = error2;
-			connection = NULL;
-		}
+		result_info = g_slice_new (NMAddConnectionResultData);
+		*result_info = (NMAddConnectionResultData) {
+			.connection    = g_object_ref (connection),
+			.extra_results = g_steal_pointer (&info->extra_results),
+		};
+		g_task_return_pointer (info->task, result_info, (GDestroyNotify) nm_add_connection_result_data_free);
 	}
 
-	info->callback (info->self,
-	                connection,
-	                connection ? info->results : NULL,
-	                error_take,
-	                info->user_data);
-
-	g_clear_error (&error_take);
-
+	g_object_unref (info->task);
 	g_object_unref (info->self);
-	nm_g_object_unref (info->cancellable);
-	nm_clear_g_free (&info->path);
-	nm_g_variant_unref (info->results);
-
+	g_free (info->connection_path);
+	nm_g_variant_unref (info->extra_results);
 	nm_g_slice_free (info);
 }
 
 static void
-_add_connection_info_cancelled (GCancellable *cancellable,
-                                AddConnectionInfo *info)
+_wait_for_connection_cancelled_cb (GCancellable *cancellable,
+                                   AddConnectionInfo *info)
 {
 	_add_connection_info_complete (info,
 	                               NULL,
@@ -246,8 +235,12 @@ connection_added (NMRemoteSettings *self,
 	else
 		g_signal_stop_emission (self, signals[CONNECTION_ADDED], 0);
 
+	/* FIXME: this doesn't look right. Why does it not care about whether the
+	 * connection is visible? Anyway, this will be reworked. */
 	path = nm_connection_get_path (NM_CONNECTION (remote));
-	info = _add_connection_info_find (self, path);
+	info =   path
+	       ? _add_connection_info_find (self, path)
+	       : NULL;
 	if (info)
 		_add_connection_info_complete (info, remote, NULL);
 }
@@ -278,51 +271,42 @@ nm_remote_settings_get_connections (NMRemoteSettings *settings)
 	return NM_REMOTE_SETTINGS_GET_PRIVATE (settings)->visible_connections;
 }
 
-static void
-add_connection_done (GObject *proxy, GAsyncResult *result, gpointer user_data)
+void
+nm_remote_settings_wait_for_connection (NMRemoteSettings *self,
+                                        const char *connection_path,
+                                        GVariant *extra_results_take,
+                                        GTask *task_take)
 {
-	AddConnectionInfo *info = user_data;
-	GError *error = NULL;
+	NMRemoteSettingsPrivate *priv;
+	gs_unref_object GTask *task = task_take;
+	gs_unref_variant GVariant *extra_results = extra_results_take;
+	GCancellable *cancellable;
+	AddConnectionInfo *info;
 
-	if (    info->ignore_out_result
-	     && info->flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK) {
-		nmdbus_settings_call_add_connection_finish (NMDBUS_SETTINGS (proxy),
-		                                            &info->path,
-		                                            result,
-		                                            &error);
-	} else if (   info->ignore_out_result
-	           && info->flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY) {
-		nmdbus_settings_call_add_connection_unsaved_finish (NMDBUS_SETTINGS (proxy),
-		                                                    &info->path,
-		                                                    result,
-		                                                    &error);
-	} else {
-		nmdbus_settings_call_add_connection2_finish (NMDBUS_SETTINGS (proxy),
-		                                             &info->path,
-		                                             &info->results,
-		                                             result,
-		                                             &error);
-		if (info->ignore_out_result) {
-			/* despite we have the result, the caller didn't ask for it.
-			 * Through it away, so we consistently don't return a result. */
-			nm_clear_pointer (&info->results, g_variant_unref);
-		}
-	}
+	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (self);
 
-	if (error) {
-		g_dbus_error_strip_remote_error (error);
-		_add_connection_info_complete (info, NULL, error);
-		return;
-	}
+	/* FIXME: there is no timeout for how long we wait. But this entire
+	 * code will be reworked, also that we have a suitable GMainContext
+	 * where we can schedule the timeout (we shouldn't use g_main_context_default()). */
 
+	info = g_slice_new (AddConnectionInfo);
+	*info = (AddConnectionInfo) {
+		.self            = g_object_ref (self),
+		.connection_path = g_strdup (connection_path),
+		.task            = g_steal_pointer (&task),
+		.extra_results   = g_steal_pointer (&extra_results),
+	};
+	c_list_link_tail (&priv->add_lst_head, &info->add_lst);
+
+	cancellable = g_task_get_cancellable (info->task);
 	/* On success, we still have to wait until the connection is fully
 	 * initialized before calling the callback.
 	 */
-	if (info->cancellable) {
+	if (cancellable) {
 		gulong id;
 
-		id = g_cancellable_connect (info->cancellable,
-		                            G_CALLBACK (_add_connection_info_cancelled),
+		id = g_cancellable_connect (cancellable,
+		                            G_CALLBACK (_wait_for_connection_cancelled_cb),
 		                            info,
 		                            NULL);
 		if (id == 0) {
@@ -331,318 +315,10 @@ add_connection_done (GObject *proxy, GAsyncResult *result, gpointer user_data)
 		} else
 			info->cancellable_id = id;
 	}
-}
 
-void
-nm_remote_settings_add_connection2 (NMRemoteSettings *self,
-                                    GVariant *settings,
-                                    NMSettingsAddConnection2Flags flags,
-                                    GVariant *args,
-                                    gboolean ignore_out_result,
-                                    GCancellable *cancellable,
-                                    NMRemoteSettingAddConnection2Callback callback,
-                                    gpointer user_data)
-{
-	NMRemoteSettingsPrivate *priv;
-	AddConnectionInfo *info;
-
-	nm_assert (NM_IS_REMOTE_SETTINGS (self));
-	nm_assert (g_variant_is_of_type (settings, G_VARIANT_TYPE ("a{sa{sv}}")));
-	nm_assert (!args || g_variant_is_of_type (args, G_VARIANT_TYPE ("a{sv}")));
-	nm_assert (callback);
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (self);
-
-	info = g_slice_new (AddConnectionInfo);
-	*info = (AddConnectionInfo) {
-		.self              = g_object_ref (self),
-		.cancellable       = nm_g_object_ref (cancellable),
-		.flags             = flags,
-		.ignore_out_result = ignore_out_result,
-		.callback          = callback,
-		.user_data         = user_data,
-	};
-	c_list_link_tail (&priv->add_lst_head, &info->add_lst);
-
-	/* Although AddConnection2() being capable to handle also AddConnection() and
-	 * AddConnectionUnsaved() variants, we prefer to use the old D-Bus methods when
-	 * they are sufficient. The reason is that libnm should avoid hard dependencies
-	 * on 1.20 API whenever possible. */
-	if (    ignore_out_result
-	     && flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_TO_DISK) {
-		nmdbus_settings_call_add_connection (priv->proxy,
-		                                     settings,
-		                                     cancellable,
-		                                     add_connection_done,
-		                                     info);
-	} else if (   ignore_out_result
-	           && flags == NM_SETTINGS_ADD_CONNECTION2_FLAG_IN_MEMORY) {
-		nmdbus_settings_call_add_connection_unsaved (priv->proxy,
-		                                             settings,
-		                                             cancellable,
-		                                             add_connection_done,
-		                                             info);
-	} else {
-		nmdbus_settings_call_add_connection2 (priv->proxy,
-		                                      settings,
-		                                      flags,
-		                                         args
-		                                      ?: g_variant_new_array (G_VARIANT_TYPE ("{sv}"), NULL, 0),
-		                                      cancellable,
-		                                      add_connection_done,
-		                                      info);
-	}
-}
-
-gboolean
-nm_remote_settings_load_connections (NMRemoteSettings *settings,
-                                     char **filenames,
-                                     char ***failures,
-                                     GCancellable *cancellable,
-                                     GError **error)
-{
-	NMRemoteSettingsPrivate *priv;
-	gboolean success;
-
-	g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
-	g_return_val_if_fail (filenames != NULL, FALSE);
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
-
-	if (!nmdbus_settings_call_load_connections_sync (priv->proxy,
-	                                                 (const char * const *) filenames,
-	                                                 &success,
-	                                                 failures,
-	                                                 cancellable, error)) {
-		if (error && *error)
-			g_dbus_error_strip_remote_error (*error);
-		success = FALSE;
-	}
-	return success;
-}
-
-static void
-load_connections_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-	gboolean success;
-	char **failures = NULL;
-
-	if (nmdbus_settings_call_load_connections_finish (NMDBUS_SETTINGS (proxy),
-	                                                  &success, &failures,
-	                                                  result, &error))
-		g_simple_async_result_set_op_res_gpointer (simple, failures, (GDestroyNotify) g_strfreev);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
-void
-nm_remote_settings_load_connections_async (NMRemoteSettings *settings,
-                                           char **filenames,
-                                           GCancellable *cancellable,
-                                           GAsyncReadyCallback callback,
-                                           gpointer user_data)
-{
-	NMRemoteSettingsPrivate *priv;
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_REMOTE_SETTINGS (settings));
-	g_return_if_fail (filenames != NULL);
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
-
-	simple = g_simple_async_result_new (G_OBJECT (settings), callback, user_data,
-	                                    nm_remote_settings_load_connections_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_settings_call_load_connections (priv->proxy,
-	                                       (const char * const *) filenames,
-	                                       cancellable, load_connections_cb, simple);
-}
-
-gboolean
-nm_remote_settings_load_connections_finish (NMRemoteSettings *settings,
-                                            char ***failures,
-                                            GAsyncResult *result,
-                                            GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (settings), nm_remote_settings_load_connections_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else {
-		*failures = g_strdupv (g_simple_async_result_get_op_res_gpointer (simple));
-		return TRUE;
-	}
-}
-
-gboolean
-nm_remote_settings_reload_connections (NMRemoteSettings *settings,
-                                       GCancellable *cancellable,
-                                       GError **error)
-{
-	NMRemoteSettingsPrivate *priv;
-	gboolean success;
-
-	g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
-
-	if (!nmdbus_settings_call_reload_connections_sync (priv->proxy, &success,
-	                                                   cancellable, error)) {
-		if (error && *error)
-			g_dbus_error_strip_remote_error (*error);
-		success = FALSE;
-	}
-
-	return success;
-}
-
-static void
-reload_connections_cb (GObject *proxy, GAsyncResult *result, gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	gboolean success;
-	GError *error = NULL;
-
-	if (nmdbus_settings_call_reload_connections_finish (NMDBUS_SETTINGS (proxy),
-	                                                    &success,
-	                                                    result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, success);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
-void
-nm_remote_settings_reload_connections_async (NMRemoteSettings *settings,
-                                             GCancellable *cancellable,
-                                             GAsyncReadyCallback callback,
-                                             gpointer user_data)
-{
-	NMRemoteSettingsPrivate *priv;
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_REMOTE_SETTINGS (settings));
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
-
-	simple = g_simple_async_result_new (G_OBJECT (settings), callback, user_data,
-	                                    nm_remote_settings_reload_connections_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_settings_call_reload_connections (priv->proxy, cancellable,
-	                                         reload_connections_cb, simple);
-}
-
-gboolean
-nm_remote_settings_reload_connections_finish (NMRemoteSettings *settings,
-                                              GAsyncResult *result,
-                                              GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (settings), nm_remote_settings_reload_connections_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
-}
-
-gboolean
-nm_remote_settings_save_hostname (NMRemoteSettings *settings,
-                                  const char *hostname,
-                                  GCancellable *cancellable,
-                                  GError **error)
-{
-	NMRemoteSettingsPrivate *priv;
-	gboolean ret;
-
-	g_return_val_if_fail (NM_IS_REMOTE_SETTINGS (settings), FALSE);
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
-
-	ret = nmdbus_settings_call_save_hostname_sync (priv->proxy,
-	                                               hostname ?: "",
-	                                               cancellable, error);
-	if (error && *error)
-		g_dbus_error_strip_remote_error (*error);
-	return ret;
-}
-
-static void
-save_hostname_cb (GObject *proxy,
-                  GAsyncResult *result,
-                  gpointer user_data)
-{
-	GSimpleAsyncResult *simple = user_data;
-	GError *error = NULL;
-
-	if (nmdbus_settings_call_save_hostname_finish (NMDBUS_SETTINGS (proxy), result, &error))
-		g_simple_async_result_set_op_res_gboolean (simple, TRUE);
-	else {
-		g_dbus_error_strip_remote_error (error);
-		g_simple_async_result_take_error (simple, error);
-	}
-	g_simple_async_result_complete (simple);
-	g_object_unref (simple);
-}
-
-void
-nm_remote_settings_save_hostname_async (NMRemoteSettings *settings,
-                                        const char *hostname,
-                                        GCancellable *cancellable,
-                                        GAsyncReadyCallback callback,
-                                        gpointer user_data)
-{
-	NMRemoteSettingsPrivate *priv;
-	GSimpleAsyncResult *simple;
-
-	g_return_if_fail (NM_IS_REMOTE_SETTINGS (settings));
-
-	priv = NM_REMOTE_SETTINGS_GET_PRIVATE (settings);
-
-	simple = g_simple_async_result_new (G_OBJECT (settings), callback, user_data,
-	                                    nm_remote_settings_save_hostname_async);
-	if (cancellable)
-		g_simple_async_result_set_check_cancellable (simple, cancellable);
-
-	nmdbus_settings_call_save_hostname (priv->proxy,
-	                                    hostname ?: "",
-	                                    cancellable, save_hostname_cb, simple);
-}
-
-gboolean
-nm_remote_settings_save_hostname_finish (NMRemoteSettings *settings,
-                                         GAsyncResult *result,
-                                         GError **error)
-{
-	GSimpleAsyncResult *simple;
-
-	g_return_val_if_fail (g_simple_async_result_is_valid (result, G_OBJECT (settings), nm_remote_settings_save_hostname_async), FALSE);
-
-	simple = G_SIMPLE_ASYNC_RESULT (result);
-	if (g_simple_async_result_propagate_error (simple, error))
-		return FALSE;
-	else
-		return g_simple_async_result_get_op_res_gboolean (simple);
+	/* FIXME: OK, we just assume the the connection is here, and that we are bound
+	 * to get the suitable signal when the connection is fully initalized (or failed).
+	 * Obviously, that needs reworking. */
 }
 
 /*****************************************************************************/
diff --git a/libnm/nm-remote-settings.h b/libnm/nm-remote-settings.h
index 6006a53b56..2ebc39d659 100644
--- a/libnm/nm-remote-settings.h
+++ b/libnm/nm-remote-settings.h
@@ -60,64 +60,19 @@ NMRemoteConnection *nm_remote_settings_get_connection_by_path (NMRemoteSettings
 NMRemoteConnection *nm_remote_settings_get_connection_by_uuid (NMRemoteSettings *settings,
                                                                const char *uuid);
 
-typedef void (*NMRemoteSettingAddConnection2Callback) (NMRemoteSettings *self,
-                                                       NMRemoteConnection *connection,
-                                                       GVariant *results,
-                                                       GError *error,
-                                                       gpointer user_data);
+typedef struct {
+	NMRemoteConnection *connection;
+	GVariant *extra_results;
+} NMAddConnectionResultData;
 
-void nm_remote_settings_add_connection2 (NMRemoteSettings *self,
-                                         GVariant *settings,
-                                         NMSettingsAddConnection2Flags flags,
-                                         GVariant *args,
-                                         gboolean ignore_out_result,
-                                         GCancellable *cancellable,
-                                         NMRemoteSettingAddConnection2Callback callback,
-                                         gpointer user_data);
+void nm_add_connection_result_data_free (NMAddConnectionResultData *result_data);
 
-_NM_DEPRECATED_SYNC_METHOD_INTERNAL
-gboolean nm_remote_settings_load_connections        (NMRemoteSettings *settings,
-                                                     char **filenames,
-                                                     char ***failures,
-                                                     GCancellable *cancellable,
-                                                     GError **error);
+NM_AUTO_DEFINE_FCN0 (NMAddConnectionResultData *, _nm_auto_free_add_connection_result_data, nm_add_connection_result_data_free)
+#define nm_auto_free_add_connection_result_data nm_auto (_nm_auto_free_add_connection_result_data)
 
-void     nm_remote_settings_load_connections_async  (NMRemoteSettings *settings,
-                                                     char **filenames,
-                                                     GCancellable *cancellable,
-                                                     GAsyncReadyCallback callback,
-                                                     gpointer user_data);
-gboolean nm_remote_settings_load_connections_finish (NMRemoteSettings *settings,
-                                                     char ***failures,
-                                                     GAsyncResult *result,
-                                                     GError **error);
-
-_NM_DEPRECATED_SYNC_METHOD_INTERNAL
-gboolean nm_remote_settings_reload_connections        (NMRemoteSettings *settings,
-                                                       GCancellable *cancellable,
-                                                       GError **error);
-
-void     nm_remote_settings_reload_connections_async  (NMRemoteSettings *settings,
-                                                       GCancellable *cancellable,
-                                                       GAsyncReadyCallback callback,
-                                                       gpointer user_data);
-gboolean nm_remote_settings_reload_connections_finish (NMRemoteSettings *settings,
-                                                       GAsyncResult *result,
-                                                       GError **error);
-
-_NM_DEPRECATED_SYNC_METHOD_INTERNAL
-gboolean nm_remote_settings_save_hostname        (NMRemoteSettings *settings,
-                                                  const char *hostname,
-                                                  GCancellable *cancellable,
-                                                  GError **error);
-
-void     nm_remote_settings_save_hostname_async  (NMRemoteSettings *settings,
-                                                  const char *hostname,
-                                                  GCancellable *cancellable,
-                                                  GAsyncReadyCallback callback,
-                                                  gpointer user_data);
-gboolean nm_remote_settings_save_hostname_finish (NMRemoteSettings *settings,
-                                                  GAsyncResult *result,
-                                                  GError **error);
+void nm_remote_settings_wait_for_connection (NMRemoteSettings *settings,
+                                             const char *connection_path,
+                                             GVariant *extra_results_take,
+                                             GTask *task_take);
 
 #endif /* __NM_REMOTE_SETTINGS_H__ */
diff --git a/libnm/tests/test-nm-client.c b/libnm/tests/test-nm-client.c
index dd9e1b2e6d..89b7900e19 100644
--- a/libnm/tests/test-nm-client.c
+++ b/libnm/tests/test-nm-client.c
@@ -1188,7 +1188,7 @@ activate_failed_cb (GObject *object,
 	NMActiveConnection *ac;
 	GError *error = NULL;
 
-	ac = nm_client_activate_connection_finish (client, result, &error);
+	ac = nm_client_add_and_activate_connection_finish (client, result, &error);
 	g_assert (ac == NULL);
 	g_assert_error (error, NM_CLIENT_ERROR, NM_CLIENT_ERROR_OBJECT_CREATION_FAILED);
 	g_clear_error (&error);
diff --git a/shared/nm-glib-aux/nm-dbus-aux.c b/shared/nm-glib-aux/nm-dbus-aux.c
index e5271a92e3..f55958b489 100644
--- a/shared/nm-glib-aux/nm-dbus-aux.c
+++ b/shared/nm-glib-aux/nm-dbus-aux.c
@@ -244,3 +244,100 @@ nm_dbus_connection_call_get_managed_objects (GDBusConnection *dbus_connection,
 	                        _nm_dbus_connection_call_get_managed_objects_cb,
 	                        nm_utils_user_data_pack (user_data, callback));
 }
+
+/*****************************************************************************/
+
+static void
+_call_finish_cb (GObject *source,
+                 GAsyncResult *result,
+                 gpointer user_data,
+                 gboolean return_void,
+                 gboolean strip_dbus_error)
+{
+	gs_unref_object GTask *task = user_data;
+	gs_unref_variant GVariant *ret = NULL;
+	GError *error = NULL;
+
+	nm_assert (G_IS_DBUS_CONNECTION (source));
+	nm_assert (G_IS_TASK (user_data));
+
+	ret = g_dbus_connection_call_finish (G_DBUS_CONNECTION (source), result, &error);
+	if (!ret) {
+		if (strip_dbus_error)
+			g_dbus_error_strip_remote_error (error);
+		g_task_return_error (task, error);
+		return;
+	}
+
+	if (!return_void) {
+		nm_assert (!g_variant_is_of_type (ret, G_VARIANT_TYPE ("()")));
+		g_task_return_pointer (task, g_steal_pointer (&ret), (GDestroyNotify) g_variant_unref);
+	} else {
+		nm_assert (g_variant_is_of_type (ret, G_VARIANT_TYPE ("()")));
+		g_task_return_boolean (task, TRUE);
+	}
+}
+
+/**
+ * nm_dbus_connection_call_finish_void_cb:
+ *
+ * A default callback to pass as callback to g_dbus_connection_call().
+ *
+ * - user_data must be a GTask, whose reference will be consumed by the
+ *   callback.
+ * - the return GVariant must be a empty tuple "()".
+ * - the GTask is returned either with error or TRUE boolean.
+ */
+void
+nm_dbus_connection_call_finish_void_cb (GObject *source,
+                                        GAsyncResult *result,
+                                        gpointer user_data)
+{
+	_call_finish_cb (source, result, user_data, TRUE, FALSE);
+}
+
+/**
+ * nm_dbus_connection_call_finish_void_strip_dbus_error_cb:
+ *
+ * Like nm_dbus_connection_call_finish_void_cb(). The difference
+ * is that on error this will first call g_dbus_error_strip_remote_error() on the error.
+ */
+void
+nm_dbus_connection_call_finish_void_strip_dbus_error_cb (GObject *source,
+                                                         GAsyncResult *result,
+                                                         gpointer user_data)
+{
+	_call_finish_cb (source, result, user_data, TRUE, TRUE);
+}
+
+/**
+ * nm_dbus_connection_call_finish_variant_cb:
+ *
+ * A default callback to pass as callback to g_dbus_connection_call().
+ *
+ * - user_data must be a GTask, whose reference will be consumed by the
+ *   callback.
+ * - the return GVariant must not be an empty tuple "()".
+ * - the GTask is returned either with error or with a pointer containing the GVariant.
+ */
+void
+nm_dbus_connection_call_finish_variant_cb (GObject *source,
+                                           GAsyncResult *result,
+                                           gpointer user_data)
+{
+	_call_finish_cb (source, result, user_data, FALSE, FALSE);
+}
+
+/**
+ * nm_dbus_connection_call_finish_variant_strip_dbus_error_cb:
+ *
+ * Like nm_dbus_connection_call_finish_variant_strip_dbus_error_cb(). The difference
+ * is that on error this will first call g_dbus_error_strip_remote_error() on the error.
+ */
+void
+nm_dbus_connection_call_finish_variant_strip_dbus_error_cb (GObject *source,
+                                                            GAsyncResult *result,
+                                                            gpointer user_data)
+{
+	_call_finish_cb (source, result, user_data, FALSE, TRUE);
+}
diff --git a/shared/nm-glib-aux/nm-dbus-aux.h b/shared/nm-glib-aux/nm-dbus-aux.h
index d37c631a0d..bf7731d22f 100644
--- a/shared/nm-glib-aux/nm-dbus-aux.h
+++ b/shared/nm-glib-aux/nm-dbus-aux.h
@@ -174,4 +174,22 @@ void nm_dbus_connection_call_get_managed_objects (GDBusConnection *dbus_connecti
 
 /*****************************************************************************/
 
+void nm_dbus_connection_call_finish_void_cb (GObject *source,
+                                             GAsyncResult *result,
+                                             gpointer user_data);
+
+void nm_dbus_connection_call_finish_void_strip_dbus_error_cb (GObject *source,
+                                                              GAsyncResult *result,
+                                                              gpointer user_data);
+
+void nm_dbus_connection_call_finish_variant_cb (GObject *source,
+                                                GAsyncResult *result,
+                                                gpointer user_data);
+
+void nm_dbus_connection_call_finish_variant_strip_dbus_error_cb (GObject *source,
+                                                                 GAsyncResult *result,
+                                                                 gpointer user_data);
+
+/*****************************************************************************/
+
 #endif /* __NM_DBUS_AUX_H__ */
diff --git a/shared/nm-glib-aux/nm-shared-utils.h b/shared/nm-glib-aux/nm-shared-utils.h
index c784a9e24b..29ff82844f 100644
--- a/shared/nm-glib-aux/nm-shared-utils.h
+++ b/shared/nm-glib-aux/nm-shared-utils.h
@@ -1256,4 +1256,30 @@ guint8 *nm_utils_hexstr2bin_alloc (const char *hexstr,
                                    gsize required_len,
                                    gsize *out_len);
 
+/*****************************************************************************/
+
+static inline GTask *
+nm_g_task_new (gpointer source_object,
+               GCancellable *cancellable,
+               gpointer source_tag,
+               GAsyncReadyCallback callback,
+               gpointer callback_data)
+{
+	GTask *task;
+
+	task = g_task_new (source_object, cancellable, callback, callback_data);
+	if (source_tag)
+		g_task_set_source_tag (task, source_tag);
+	return task;
+}
+
+static inline gboolean
+nm_g_task_is_valid (gpointer task,
+                    gpointer source_object,
+                    gpointer source_tag)
+{
+	return    g_task_is_valid (task, source_object)
+	       && g_task_get_source_tag (task) == source_tag;
+}
+
 #endif /* __NM_SHARED_UTILS_H__ */
diff --git a/src/settings/nm-settings.c b/src/settings/nm-settings.c
index a8377a5aba..1029474fc5 100644
--- a/src/settings/nm-settings.c
+++ b/src/settings/nm-settings.c
@@ -2821,6 +2821,7 @@ impl_settings_reload_connections (NMDBusObject *obj,
 
 	nm_audit_log_connection_op (NM_AUDIT_OP_CONNS_RELOAD, NULL, TRUE, NULL, invocation, NULL);
 
+	/* We MUST return %TRUE here, otherwise older libnm versions might misbehave. */
 	g_dbus_method_invocation_return_value (invocation, g_variant_new ("(b)", TRUE));
 }