New upstream version 1.27.90 upstream/1.27.90

1 files changed, 1234 insertions, 1211 deletions

diff --git a/src/settings/nm-agent-manager.c b/src/settings/nm-agent-manager.c
index 363b1175..07a3dafe 100644
--- a/src/settings/nm-agent-manager.c
+++ b/src/settings/nm-agent-manager.c
@@ -1,4 +1,4 @@
-// SPDX-License-Identifier: GPL-2.0+
+/* SPDX-License-Identifier: GPL-2.0+ */
 /*
  * Copyright (C) 2010 - 2013 Red Hat, Inc.
  */
@@ -25,1135 +25,1179 @@
 /*****************************************************************************/
 
 enum {
-	AGENT_REGISTERED,
-	LAST_SIGNAL,
+    AGENT_REGISTERED,
+    LAST_SIGNAL,
 };
 
-static guint signals[LAST_SIGNAL] = { 0 };
+static guint signals[LAST_SIGNAL] = {0};
 
 typedef struct {
-	NMAuthManager *auth_mgr;
-	NMSessionMonitor *session_monitor;
+    NMAuthManager *   auth_mgr;
+    NMSessionMonitor *session_monitor;
 
-	CList agent_lst_head;
+    CList agent_lst_head;
 
-	CList request_lst_head;
+    CList request_lst_head;
 
-	guint64 agent_version_id;
+    guint64 agent_version_id;
 } NMAgentManagerPrivate;
 
 struct _NMAgentManager {
-	NMDBusObject parent;
-	NMAgentManagerPrivate _priv;
+    NMDBusObject          parent;
+    NMAgentManagerPrivate _priv;
 };
 
 struct _NMAgentManagerClass {
-	NMDBusObjectClass parent;
+    NMDBusObjectClass parent;
 };
 
-G_DEFINE_TYPE (NMAgentManager, nm_agent_manager, NM_TYPE_DBUS_OBJECT)
+G_DEFINE_TYPE(NMAgentManager, nm_agent_manager, NM_TYPE_DBUS_OBJECT)
 
-#define NM_AGENT_MANAGER_GET_PRIVATE(self) _NM_GET_PRIVATE (self, NMAgentManager, NM_IS_AGENT_MANAGER)
+#define NM_AGENT_MANAGER_GET_PRIVATE(self) \
+    _NM_GET_PRIVATE(self, NMAgentManager, NM_IS_AGENT_MANAGER)
 
 /*****************************************************************************/
 
-NM_DEFINE_SINGLETON_GETTER (NMAgentManager, nm_agent_manager_get, NM_TYPE_AGENT_MANAGER);
+NM_DEFINE_SINGLETON_GETTER(NMAgentManager, nm_agent_manager_get, NM_TYPE_AGENT_MANAGER);
 
 /*****************************************************************************/
 
-#define _NMLOG_PREFIX_NAME    "agent-manager"
-#define _NMLOG_DOMAIN         LOGD_AGENTS
-#define _NMLOG(level, agent, ...) \
-    G_STMT_START { \
-        if (nm_logging_enabled ((level), (_NMLOG_DOMAIN))) { \
-            char __prefix1[32]; \
-            char __prefix2[128]; \
-            NMSecretAgent *__agent = (agent); \
-            \
-            if (!(self)) \
-                g_snprintf (__prefix1, sizeof (__prefix1), "%s%s", ""_NMLOG_PREFIX_NAME"", "[]"); \
-            else if ((self) != singleton_instance) \
-                g_snprintf (__prefix1, sizeof (__prefix1), "%s["NM_HASH_OBFUSCATE_PTR_FMT"]", ""_NMLOG_PREFIX_NAME"", NM_HASH_OBFUSCATE_PTR (self)); \
-            else \
-                g_strlcpy (__prefix1, _NMLOG_PREFIX_NAME, sizeof (__prefix1)); \
-            if (__agent) { \
-                g_snprintf (__prefix2, sizeof (__prefix2), \
-                            ": agent["NM_HASH_OBFUSCATE_PTR_FMT",%s]", \
-                            NM_HASH_OBFUSCATE_PTR (__agent), \
-                            nm_secret_agent_get_description (__agent)); \
-            } else \
-                __prefix2[0] = '\0'; \
-            _nm_log ((level), (_NMLOG_DOMAIN), 0, NULL, NULL, \
-                     "%s%s: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
-                     __prefix1, __prefix2 _NM_UTILS_MACRO_REST(__VA_ARGS__)); \
-        } \
-    } G_STMT_END
-
-#define LOG_REQ_FMT          "["NM_HASH_OBFUSCATE_PTR_FMT"/%s%s%s%s%s%s]"
-#define LOG_REQ_ARG(req) \
-	NM_HASH_OBFUSCATE_PTR (req), \
-	NM_PRINT_FMT_QUOTE_STRING ((req)->detail), \
-	NM_PRINT_FMT_QUOTED (((req)->request_type == REQUEST_TYPE_CON_GET) && (req)->con.get.setting_name, \
-	                     "/\"", (req)->con.get.setting_name, "\"", \
-	                     ((req)->request_type == REQUEST_TYPE_CON_GET ? "/(none)" : _request_type_to_string ((req)->request_type, FALSE)))
+#define _NMLOG_PREFIX_NAME "agent-manager"
+#define _NMLOG_DOMAIN      LOGD_AGENTS
+#define _NMLOG(level, agent, ...)                                            \
+    G_STMT_START                                                             \
+    {                                                                        \
+        if (nm_logging_enabled((level), (_NMLOG_DOMAIN))) {                  \
+            char           __prefix1[32];                                    \
+            char           __prefix2[128];                                   \
+            NMSecretAgent *__agent = (agent);                                \
+                                                                             \
+            if (!(self))                                                     \
+                g_snprintf(__prefix1,                                        \
+                           sizeof(__prefix1),                                \
+                           "%s%s",                                           \
+                           ""_NMLOG_PREFIX_NAME                              \
+                           "",                                               \
+                           "[]");                                            \
+            else if ((self) != singleton_instance)                           \
+                g_snprintf(__prefix1,                                        \
+                           sizeof(__prefix1),                                \
+                           "%s[" NM_HASH_OBFUSCATE_PTR_FMT "]",              \
+                           ""_NMLOG_PREFIX_NAME                              \
+                           "",                                               \
+                           NM_HASH_OBFUSCATE_PTR(self));                     \
+            else                                                             \
+                g_strlcpy(__prefix1, _NMLOG_PREFIX_NAME, sizeof(__prefix1)); \
+            if (__agent) {                                                   \
+                g_snprintf(__prefix2,                                        \
+                           sizeof(__prefix2),                                \
+                           ": agent[" NM_HASH_OBFUSCATE_PTR_FMT ",%s]",      \
+                           NM_HASH_OBFUSCATE_PTR(__agent),                   \
+                           nm_secret_agent_get_description(__agent));        \
+            } else                                                           \
+                __prefix2[0] = '\0';                                         \
+            _nm_log((level),                                                 \
+                    (_NMLOG_DOMAIN),                                         \
+                    0,                                                       \
+                    NULL,                                                    \
+                    NULL,                                                    \
+                    "%s%s: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__),             \
+                    __prefix1,                                               \
+                    __prefix2 _NM_UTILS_MACRO_REST(__VA_ARGS__));            \
+        }                                                                    \
+    }                                                                        \
+    G_STMT_END
+
+#define LOG_REQ_FMT "[" NM_HASH_OBFUSCATE_PTR_FMT "/%s%s%s%s%s%s]"
+#define LOG_REQ_ARG(req)                                                  \
+    NM_HASH_OBFUSCATE_PTR(req), NM_PRINT_FMT_QUOTE_STRING((req)->detail), \
+        NM_PRINT_FMT_QUOTED(((req)->request_type == REQUEST_TYPE_CON_GET) \
+                                && (req)->con.get.setting_name,           \
+                            "/\"",                                        \
+                            (req)->con.get.setting_name,                  \
+                            "\"",                                         \
+                            ((req)->request_type == REQUEST_TYPE_CON_GET  \
+                                 ? "/(none)"                              \
+                                 : _request_type_to_string((req)->request_type, FALSE)))
 
 /*****************************************************************************/
 
 typedef struct _NMAgentManagerCallId Request;
 
-static void request_add_agent (Request *req, NMSecretAgent *agent);
+static void request_add_agent(Request *req, NMSecretAgent *agent);
 
-static void request_remove_agent (Request *req, NMSecretAgent *agent);
+static void request_remove_agent(Request *req, NMSecretAgent *agent);
 
-static void request_next_agent (Request *req);
+static void request_next_agent(Request *req);
 
-static void _con_get_request_start (Request *req);
-static void _con_save_request_start (Request *req);
-static void _con_del_request_start (Request *req);
+static void _con_get_request_start(Request *req);
+static void _con_save_request_start(Request *req);
+static void _con_del_request_start(Request *req);
 
-static gboolean _con_get_try_complete_early (Request *req);
+static gboolean _con_get_try_complete_early(Request *req);
 
-static void agent_disconnected_cb (NMSecretAgent *agent, gpointer user_data);
+static void agent_disconnected_cb(NMSecretAgent *agent, gpointer user_data);
 
 /*****************************************************************************/
 
 guint64
-nm_agent_manager_get_agent_version_id (NMAgentManager *self)
+nm_agent_manager_get_agent_version_id(NMAgentManager *self)
 {
-	g_return_val_if_fail (NM_IS_AGENT_MANAGER (self), 0);
+    g_return_val_if_fail(NM_IS_AGENT_MANAGER(self), 0);
 
-	return NM_AGENT_MANAGER_GET_PRIVATE (self)->agent_version_id;
+    return NM_AGENT_MANAGER_GET_PRIVATE(self)->agent_version_id;
 }
 
 /*****************************************************************************/
 
 typedef enum {
-	REQUEST_TYPE_INVALID,
-	REQUEST_TYPE_CON_GET,
-	REQUEST_TYPE_CON_SAVE,
-	REQUEST_TYPE_CON_DEL,
+    REQUEST_TYPE_INVALID,
+    REQUEST_TYPE_CON_GET,
+    REQUEST_TYPE_CON_SAVE,
+    REQUEST_TYPE_CON_DEL,
 } RequestType;
 
 static const char *
-_request_type_to_string (RequestType request_type, gboolean verbose)
+_request_type_to_string(RequestType request_type, gboolean verbose)
 {
-	switch (request_type) {
-	case REQUEST_TYPE_CON_GET:  return verbose ? "getting"  : "get";
-	case REQUEST_TYPE_CON_SAVE: return verbose ? "saving"   : "sav";
-	case REQUEST_TYPE_CON_DEL:  return verbose ? "deleting" : "del";
-	default: return "??";
-	}
+    switch (request_type) {
+    case REQUEST_TYPE_CON_GET:
+        return verbose ? "getting" : "get";
+    case REQUEST_TYPE_CON_SAVE:
+        return verbose ? "saving" : "sav";
+    case REQUEST_TYPE_CON_DEL:
+        return verbose ? "deleting" : "del";
+    default:
+        return "??";
+    }
 }
 
 /*****************************************************************************/
 
 struct _NMAgentManagerCallId {
-	CList request_lst;
+    CList request_lst;
 
-	NMAgentManager *self;
+    NMAgentManager *self;
 
-	RequestType request_type;
+    RequestType request_type;
 
-	char *detail;
+    char *detail;
 
-	NMAuthSubject *subject;
+    NMAuthSubject *subject;
 
-	/* Current agent being asked for secrets */
-	NMSecretAgent *current;
-	NMSecretAgentCallId *current_call_id;
+    /* Current agent being asked for secrets */
+    NMSecretAgent *      current;
+    NMSecretAgentCallId *current_call_id;
 
-	/* Stores the sorted list of NMSecretAgents which will be asked for secrets */
-	GSList *pending;
+    /* Stores the sorted list of NMSecretAgents which will be asked for secrets */
+    GSList *pending;
 
-	guint idle_id;
+    guint idle_id;
 
-	union {
-		struct {
-			char *path;
-			NMConnection *connection;
+    union {
+        struct {
+            char *        path;
+            NMConnection *connection;
 
-			NMAuthChain *chain;
+            NMAuthChain *chain;
 
-			/* Whether the agent currently being asked for secrets
-			 * has the system.modify privilege.
-			 */
-			gboolean current_has_modify;
+            /* Whether the agent currently being asked for secrets
+             * has the system.modify privilege.
+             */
+            gboolean current_has_modify;
 
-			union {
-				struct {
-					NMSecretAgentGetSecretsFlags flags;
-					char *setting_name;
-					char **hints;
+            union {
+                struct {
+                    NMSecretAgentGetSecretsFlags flags;
+                    char *                       setting_name;
+                    char **                      hints;
 
-					GVariant *existing_secrets;
+                    GVariant *existing_secrets;
 
-					NMAgentSecretsResultFunc callback;
-					gpointer callback_data;
-				} get;
-			};
-		} con;
-	};
+                    NMAgentSecretsResultFunc callback;
+                    gpointer                 callback_data;
+                } get;
+            };
+        } con;
+    };
 };
 
 /*****************************************************************************/
 
 static NMSecretAgent *
-_agent_find_by_owner (NMAgentManagerPrivate *priv,
-                      const char *owner)
+_agent_find_by_owner(NMAgentManagerPrivate *priv, const char *owner)
 {
-	NMSecretAgent *agent;
+    NMSecretAgent *agent;
 
-	c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
-		if (nm_streq (nm_secret_agent_get_dbus_owner (agent), owner))
-			return agent;
-	}
-	return NULL;
+    c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
+        if (nm_streq(nm_secret_agent_get_dbus_owner(agent), owner))
+            return agent;
+    }
+    return NULL;
 }
 
 static NMSecretAgent *
-_agent_find_by_identifier_and_uid (NMAgentManagerPrivate *priv,
-                                   const char *identifier,
-                                   gulong sender_uid)
+_agent_find_by_identifier_and_uid(NMAgentManagerPrivate *priv,
+                                  const char *           identifier,
+                                  gulong                 sender_uid)
 {
-	NMSecretAgent *agent;
-
-	c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
-		if (    nm_streq0 (nm_secret_agent_get_identifier (agent), identifier)
-		    && sender_uid == nm_secret_agent_get_owner_uid (agent))
-			return agent;
-	}
-	return NULL;
+    NMSecretAgent *agent;
+
+    c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
+        if (nm_streq0(nm_secret_agent_get_identifier(agent), identifier)
+            && sender_uid == nm_secret_agent_get_owner_uid(agent))
+            return agent;
+    }
+    return NULL;
 }
 
 /*****************************************************************************/
 
 static void
-_agent_remove (NMAgentManager *self, NMSecretAgent *agent)
+_agent_remove(NMAgentManager *self, NMSecretAgent *agent)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	CList *iter, *safe;
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    CList *                iter, *safe;
 
-	nm_assert (NM_IS_SECRET_AGENT (agent));
-	nm_assert (c_list_contains (&priv->agent_lst_head, &agent->agent_lst));
+    nm_assert(NM_IS_SECRET_AGENT(agent));
+    nm_assert(c_list_contains(&priv->agent_lst_head, &agent->agent_lst));
 
-	_LOGD (agent, "agent unregistered or disappeared");
+    _LOGD(agent, "agent unregistered or disappeared");
 
-	nm_clear_pointer (&agent->auth_chain, nm_auth_chain_destroy);
+    nm_clear_pointer(&agent->auth_chain, nm_auth_chain_destroy);
 
-	c_list_unlink (&agent->agent_lst);
+    c_list_unlink(&agent->agent_lst);
 
-	g_signal_handlers_disconnect_by_func (agent, G_CALLBACK (agent_disconnected_cb), self);
+    g_signal_handlers_disconnect_by_func(agent, G_CALLBACK(agent_disconnected_cb), self);
 
-	/* Remove this agent from any in-progress secrets requests */
-	c_list_for_each_safe (iter, safe, &priv->request_lst_head)
-		request_remove_agent (c_list_entry (iter, Request, request_lst), agent);
+    /* Remove this agent from any in-progress secrets requests */
+    c_list_for_each_safe (iter, safe, &priv->request_lst_head)
+        request_remove_agent(c_list_entry(iter, Request, request_lst), agent);
 
-	g_object_unref (agent);
+    g_object_unref(agent);
 }
 
 /* Call this *after* calling request_next_agent() */
 static void
-maybe_remove_agent_on_error (NMAgentManager *self,
-                             NMSecretAgent *agent,
-                             GError *error)
+maybe_remove_agent_on_error(NMAgentManager *self, NMSecretAgent *agent, GError *error)
 {
-	if (   !g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CLOSED)
-	    && !g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_DISCONNECTED)
-	    && !g_error_matches (error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER))
-		return;
+    if (!g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CLOSED)
+        && !g_error_matches(error, G_DBUS_ERROR, G_DBUS_ERROR_DISCONNECTED)
+        && !g_error_matches(error, G_DBUS_ERROR, G_DBUS_ERROR_NAME_HAS_NO_OWNER))
+        return;
 
-	if (!c_list_is_empty (&agent->agent_lst))
-		_agent_remove (self, agent);
+    if (!c_list_is_empty(&agent->agent_lst))
+        _agent_remove(self, agent);
 }
 
 /*****************************************************************************/
 
 static gboolean
-validate_identifier (const char *identifier, GError **error)
+validate_identifier(const char *identifier, GError **error)
 {
-	const char *p = identifier;
-	size_t id_len;
-
-	if (!identifier) {
-		g_set_error_literal (error,
-		                     NM_AGENT_MANAGER_ERROR,
-		                     NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
-		                     "No identifier was given");
-		return FALSE;
-	}
-
-	/* Length between 3 and 255 characters inclusive */
-	id_len = strlen (identifier);
-	if (id_len < 3 || id_len > 255) {
-		g_set_error_literal (error,
-		                     NM_AGENT_MANAGER_ERROR,
-		                     NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
-		                     "Identifier length not between 3 and 255 characters (inclusive)");
-		return FALSE;
-	}
-
-	if ((identifier[0] == '.') || (identifier[id_len - 1] == '.')) {
-		g_set_error_literal (error,
-		                     NM_AGENT_MANAGER_ERROR,
-		                     NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
-		                     "Identifier must not start or end with '.'");
-		return FALSE;
-	}
-
-	/* FIXME: do complete validation here */
-	while (p && *p) {
-		if (!g_ascii_isalnum (*p) && (*p != '_') && (*p != '-') && (*p != '.')) {
-			g_set_error (error,
-			             NM_AGENT_MANAGER_ERROR,
-				         NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
-				         "Identifier contains invalid character '%c'", *p);
-			return FALSE;
-		}
-
-		if ((*p == '.') && (*(p + 1) == '.')) {
-			g_set_error_literal (error,
-			                     NM_AGENT_MANAGER_ERROR,
-				                 NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
-				                 "Identifier contains two '.' characters in sequence");
-			return FALSE;
-		}
-		p++;
-	}
-
-	return TRUE;
+    const char *p = identifier;
+    size_t      id_len;
+
+    if (!identifier) {
+        g_set_error_literal(error,
+                            NM_AGENT_MANAGER_ERROR,
+                            NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
+                            "No identifier was given");
+        return FALSE;
+    }
+
+    /* Length between 3 and 255 characters inclusive */
+    id_len = strlen(identifier);
+    if (id_len < 3 || id_len > 255) {
+        g_set_error_literal(error,
+                            NM_AGENT_MANAGER_ERROR,
+                            NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
+                            "Identifier length not between 3 and 255 characters (inclusive)");
+        return FALSE;
+    }
+
+    if ((identifier[0] == '.') || (identifier[id_len - 1] == '.')) {
+        g_set_error_literal(error,
+                            NM_AGENT_MANAGER_ERROR,
+                            NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
+                            "Identifier must not start or end with '.'");
+        return FALSE;
+    }
+
+    /* FIXME: do complete validation here */
+    while (p && *p) {
+        if (!g_ascii_isalnum(*p) && (*p != '_') && (*p != '-') && (*p != '.')) {
+            g_set_error(error,
+                        NM_AGENT_MANAGER_ERROR,
+                        NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
+                        "Identifier contains invalid character '%c'",
+                        *p);
+            return FALSE;
+        }
+
+        if ((*p == '.') && (*(p + 1) == '.')) {
+            g_set_error_literal(error,
+                                NM_AGENT_MANAGER_ERROR,
+                                NM_AGENT_MANAGER_ERROR_INVALID_IDENTIFIER,
+                                "Identifier contains two '.' characters in sequence");
+            return FALSE;
+        }
+        p++;
+    }
+
+    return TRUE;
 }
 
 static void
-_agent_permissions_check_done (NMAuthChain *chain,
-                               GDBusMethodInvocation *context,
-                               gpointer user_data)
+_agent_permissions_check_done(NMAuthChain *          chain,
+                              GDBusMethodInvocation *context,
+                              gpointer               user_data)
 {
-	NMAgentManager *self = NM_AGENT_MANAGER (user_data);
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	NMSecretAgent *agent;
-	Request *request;
+    NMAgentManager *       self = NM_AGENT_MANAGER(user_data);
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    NMSecretAgent *        agent;
+    Request *              request;
 
-	nm_assert (!context || G_IS_DBUS_METHOD_INVOCATION (context));
+    nm_assert(!context || G_IS_DBUS_METHOD_INVOCATION(context));
 
-	agent = nm_auth_chain_steal_data (chain, "agent");
+    agent = nm_auth_chain_steal_data(chain, "agent");
 
-	nm_assert (NM_IS_SECRET_AGENT (agent));
-	nm_assert (agent->auth_chain == chain);
-	nm_assert (agent->fully_registered == (!context));
-	nm_assert (c_list_contains (&priv->agent_lst_head, &agent->agent_lst));
+    nm_assert(NM_IS_SECRET_AGENT(agent));
+    nm_assert(agent->auth_chain == chain);
+    nm_assert(agent->fully_registered == (!context));
+    nm_assert(c_list_contains(&priv->agent_lst_head, &agent->agent_lst));
 
-	agent->auth_chain = NULL;
+    agent->auth_chain = NULL;
 
-	nm_secret_agent_add_permission (agent,
-	                                NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED,
-	                                (nm_auth_chain_get_result (chain, NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED) == NM_AUTH_CALL_RESULT_YES));
-	nm_secret_agent_add_permission (agent,
-	                                NM_AUTH_PERMISSION_WIFI_SHARE_OPEN,
-	                                (nm_auth_chain_get_result (chain, NM_AUTH_PERMISSION_WIFI_SHARE_OPEN) == NM_AUTH_CALL_RESULT_YES));
+    nm_secret_agent_add_permission(
+        agent,
+        NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED,
+        (nm_auth_chain_get_result(chain, NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED)
+         == NM_AUTH_CALL_RESULT_YES));
+    nm_secret_agent_add_permission(
+        agent,
+        NM_AUTH_PERMISSION_WIFI_SHARE_OPEN,
+        (nm_auth_chain_get_result(chain, NM_AUTH_PERMISSION_WIFI_SHARE_OPEN)
+         == NM_AUTH_CALL_RESULT_YES));
 
-	if (agent->fully_registered) {
-		_LOGD (agent, "updated agent permissions");
-		return;
-	}
+    if (agent->fully_registered) {
+        _LOGD(agent, "updated agent permissions");
+        return;
+    }
 
-	_LOGI (agent, "agent registered");
+    _LOGI(agent, "agent registered");
 
-	agent->fully_registered = TRUE;
+    agent->fully_registered = TRUE;
 
-	priv->agent_version_id += 1;
+    priv->agent_version_id += 1;
 
-	g_dbus_method_invocation_return_value (context, NULL);
+    g_dbus_method_invocation_return_value(context, NULL);
 
-	c_list_for_each_entry (request, &priv->request_lst_head, request_lst)
-		request_add_agent (request, agent);
+    c_list_for_each_entry (request, &priv->request_lst_head, request_lst)
+        request_add_agent(request, agent);
 
-	g_signal_emit (self, signals[AGENT_REGISTERED], 0, agent);
+    g_signal_emit(self, signals[AGENT_REGISTERED], 0, agent);
 }
 
 static NMAuthChain *
-_agent_create_auth_chain (NMAgentManager *self,
-                          NMSecretAgent *agent,
-                          GDBusMethodInvocation *context)
+_agent_create_auth_chain(NMAgentManager *self, NMSecretAgent *agent, GDBusMethodInvocation *context)
 {
-	NMAuthChain *chain;
-
-	_LOGD (agent, "requesting permissions");
-
-	nm_assert (   !agent->auth_chain
-	           || (agent->fully_registered == (!nm_auth_chain_get_context (agent->auth_chain))));
-
-	if (   agent->auth_chain
-	    && !context
-	    && !agent->fully_registered) {
-		/* we restart the authorization check (without a @context), but the currently
-		 * pending auth-chain carries a context. We need to pass it on as we replace
-		 * the auth-chain. */
-		context = nm_auth_chain_get_context (agent->auth_chain);
-		nm_assert (context);
-	}
-
-	chain = nm_auth_chain_new_subject (nm_secret_agent_get_subject (agent),
-	                                   context,
-	                                   _agent_permissions_check_done,
-	                                   self);
-
-	nm_auth_chain_set_data (chain, "agent", agent, NULL);
-	nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED, FALSE);
-	nm_auth_chain_add_call (chain, NM_AUTH_PERMISSION_WIFI_SHARE_OPEN, FALSE);
-
-	nm_clear_pointer (&agent->auth_chain, nm_auth_chain_destroy);
-	agent->auth_chain = chain;
-	return chain;
+    NMAuthChain *chain;
+
+    _LOGD(agent, "requesting permissions");
+
+    nm_assert(!agent->auth_chain
+              || (agent->fully_registered == (!nm_auth_chain_get_context(agent->auth_chain))));
+
+    if (agent->auth_chain && !context && !agent->fully_registered) {
+        /* we restart the authorization check (without a @context), but the currently
+         * pending auth-chain carries a context. We need to pass it on as we replace
+         * the auth-chain. */
+        context = nm_auth_chain_get_context(agent->auth_chain);
+        nm_assert(context);
+    }
+
+    chain = nm_auth_chain_new_subject(nm_secret_agent_get_subject(agent),
+                                      context,
+                                      _agent_permissions_check_done,
+                                      self);
+
+    nm_auth_chain_set_data(chain, "agent", agent, NULL);
+    nm_auth_chain_add_call(chain, NM_AUTH_PERMISSION_WIFI_SHARE_PROTECTED, FALSE);
+    nm_auth_chain_add_call(chain, NM_AUTH_PERMISSION_WIFI_SHARE_OPEN, FALSE);
+
+    nm_clear_pointer(&agent->auth_chain, nm_auth_chain_destroy);
+    agent->auth_chain = chain;
+    return chain;
 }
 
 static void
-agent_disconnected_cb (NMSecretAgent *agent, gpointer user_data)
+agent_disconnected_cb(NMSecretAgent *agent, gpointer user_data)
 {
-	_agent_remove (NM_AGENT_MANAGER (user_data), agent);
+    _agent_remove(NM_AGENT_MANAGER(user_data), agent);
 }
 
 static void
-agent_manager_register_with_capabilities (NMAgentManager *self,
-                                          GDBusMethodInvocation *context,
-                                          const char *identifier,
-                                          guint32 capabilities)
+agent_manager_register_with_capabilities(NMAgentManager *       self,
+                                         GDBusMethodInvocation *context,
+                                         const char *           identifier,
+                                         guint32                capabilities)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	gs_unref_object NMAuthSubject *subject = NULL;
-	gulong sender_uid = G_MAXULONG;
-	GError *error = NULL;
-	NMSecretAgent *agent;
-
-	subject = nm_dbus_manager_new_auth_subject_from_context (context);
-	if (!subject) {
-		error = g_error_new_literal (NM_AGENT_MANAGER_ERROR,
-		                             NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED,
-		                             NM_UTILS_ERROR_MSG_REQ_UID_UKNOWN);
-		g_dbus_method_invocation_take_error (context, error);
-		return;
-	}
-	sender_uid = nm_auth_subject_get_unix_process_uid (subject);
-
-	/* Validate the identifier */
-	if (!validate_identifier (identifier, &error)) {
-		g_dbus_method_invocation_take_error (context, error);
-		return;
-	}
-
-	/* Only one agent for each identifier is allowed per user */
-	if (_agent_find_by_identifier_and_uid (priv, identifier, sender_uid)) {
-		error = g_error_new_literal (NM_AGENT_MANAGER_ERROR,
-		                             NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED,
-		                             "An agent with this ID is already registered for this user.");
-		g_dbus_method_invocation_take_error (context, error);
-		return;
-	}
-
-	agent = nm_secret_agent_new (context, subject, identifier, capabilities);
-
-	g_signal_connect (agent, NM_SECRET_AGENT_DISCONNECTED,
-	                  G_CALLBACK (agent_disconnected_cb), self);
-
-	c_list_link_tail (&priv->agent_lst_head, &agent->agent_lst);
-
-	_agent_create_auth_chain (self, agent, context);
+    NMAgentManagerPrivate *priv               = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    gs_unref_object NMAuthSubject *subject    = NULL;
+    gulong                         sender_uid = G_MAXULONG;
+    GError *                       error      = NULL;
+    NMSecretAgent *                agent;
+
+    subject = nm_dbus_manager_new_auth_subject_from_context(context);
+    if (!subject) {
+        error = g_error_new_literal(NM_AGENT_MANAGER_ERROR,
+                                    NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED,
+                                    NM_UTILS_ERROR_MSG_REQ_UID_UKNOWN);
+        g_dbus_method_invocation_take_error(context, error);
+        return;
+    }
+    sender_uid = nm_auth_subject_get_unix_process_uid(subject);
+
+    /* Validate the identifier */
+    if (!validate_identifier(identifier, &error)) {
+        g_dbus_method_invocation_take_error(context, error);
+        return;
+    }
+
+    /* Only one agent for each identifier is allowed per user */
+    if (_agent_find_by_identifier_and_uid(priv, identifier, sender_uid)) {
+        error = g_error_new_literal(NM_AGENT_MANAGER_ERROR,
+                                    NM_AGENT_MANAGER_ERROR_PERMISSION_DENIED,
+                                    "An agent with this ID is already registered for this user.");
+        g_dbus_method_invocation_take_error(context, error);
+        return;
+    }
+
+    agent = nm_secret_agent_new(context, subject, identifier, capabilities);
+
+    g_signal_connect(agent, NM_SECRET_AGENT_DISCONNECTED, G_CALLBACK(agent_disconnected_cb), self);
+
+    c_list_link_tail(&priv->agent_lst_head, &agent->agent_lst);
+
+    _agent_create_auth_chain(self, agent, context);
 }
 
 static void
-impl_agent_manager_register (NMDBusObject *obj,
-                             const NMDBusInterfaceInfoExtended *interface_info,
-                             const NMDBusMethodInfoExtended *method_info,
-                             GDBusConnection *connection,
-                             const char *sender,
-                             GDBusMethodInvocation *invocation,
-                             GVariant *parameters)
+impl_agent_manager_register(NMDBusObject *                     obj,
+                            const NMDBusInterfaceInfoExtended *interface_info,
+                            const NMDBusMethodInfoExtended *   method_info,
+                            GDBusConnection *                  connection,
+                            const char *                       sender,
+                            GDBusMethodInvocation *            invocation,
+                            GVariant *                         parameters)
 {
-	const char *identifier;
+    const char *identifier;
 
-	g_variant_get (parameters, "(&s)", &identifier);
-	agent_manager_register_with_capabilities (NM_AGENT_MANAGER (obj), invocation, identifier, 0);
+    g_variant_get(parameters, "(&s)", &identifier);
+    agent_manager_register_with_capabilities(NM_AGENT_MANAGER(obj), invocation, identifier, 0);
 }
 
 static void
-impl_agent_manager_register_with_capabilities (NMDBusObject *obj,
-                                               const NMDBusInterfaceInfoExtended *interface_info,
-                                               const NMDBusMethodInfoExtended *method_info,
-                                               GDBusConnection *connection,
-                                               const char *sender,
-                                               GDBusMethodInvocation *invocation,
-                                               GVariant *parameters)
+impl_agent_manager_register_with_capabilities(NMDBusObject *                     obj,
+                                              const NMDBusInterfaceInfoExtended *interface_info,
+                                              const NMDBusMethodInfoExtended *   method_info,
+                                              GDBusConnection *                  connection,
+                                              const char *                       sender,
+                                              GDBusMethodInvocation *            invocation,
+                                              GVariant *                         parameters)
 {
-	const char *identifier;
-	guint32 capabilities;
-
-	g_variant_get (parameters, "(&su)", &identifier, &capabilities);
-	agent_manager_register_with_capabilities (NM_AGENT_MANAGER (obj), invocation, identifier, capabilities);
+    const char *identifier;
+    guint32     capabilities;
+
+    g_variant_get(parameters, "(&su)", &identifier, &capabilities);
+    agent_manager_register_with_capabilities(NM_AGENT_MANAGER(obj),
+                                             invocation,
+                                             identifier,
+                                             capabilities);
 }
 
 static void
-impl_agent_manager_unregister (NMDBusObject *obj,
-                               const NMDBusInterfaceInfoExtended *interface_info,
-                               const NMDBusMethodInfoExtended *method_info,
-                               GDBusConnection *connection,
-                               const char *sender,
-                               GDBusMethodInvocation *invocation,
-                               GVariant *parameters)
+impl_agent_manager_unregister(NMDBusObject *                     obj,
+                              const NMDBusInterfaceInfoExtended *interface_info,
+                              const NMDBusMethodInfoExtended *   method_info,
+                              GDBusConnection *                  connection,
+                              const char *                       sender,
+                              GDBusMethodInvocation *            invocation,
+                              GVariant *                         parameters)
 {
-	NMAgentManager *self = NM_AGENT_MANAGER (obj);
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	NMSecretAgent *agent;
-
-	agent = _agent_find_by_owner (priv, sender);
-	if (!agent) {
-		g_dbus_method_invocation_return_error_literal (invocation,
-		                                               NM_AGENT_MANAGER_ERROR,
-		                                               NM_AGENT_MANAGER_ERROR_NOT_REGISTERED,
-		                                               "Caller is not registered as an Agent");
-		return;
-	}
-
-	_agent_remove (self, agent);
-
-	g_dbus_method_invocation_return_value (invocation, NULL);
+    NMAgentManager *       self = NM_AGENT_MANAGER(obj);
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    NMSecretAgent *        agent;
+
+    agent = _agent_find_by_owner(priv, sender);
+    if (!agent) {
+        g_dbus_method_invocation_return_error_literal(invocation,
+                                                      NM_AGENT_MANAGER_ERROR,
+                                                      NM_AGENT_MANAGER_ERROR_NOT_REGISTERED,
+                                                      "Caller is not registered as an Agent");
+        return;
+    }
+
+    _agent_remove(self, agent);
+
+    g_dbus_method_invocation_return_value(invocation, NULL);
 }
 
 /*****************************************************************************/
 
 static Request *
-request_new (NMAgentManager *self,
-             RequestType request_type,
-             const char *detail,
-             NMAuthSubject *subject)
+request_new(NMAgentManager *self,
+            RequestType     request_type,
+            const char *    detail,
+            NMAuthSubject * subject)
 {
-	Request *req;
-
-	req = g_slice_new0 (Request);
-	req->self = g_object_ref (self);
-	req->request_type = request_type;
-	req->detail = g_strdup (detail);
-	req->subject = g_object_ref (subject);
-	c_list_link_tail (&NM_AGENT_MANAGER_GET_PRIVATE (self)->request_lst_head, &req->request_lst);
-	return req;
+    Request *req;
+
+    req               = g_slice_new0(Request);
+    req->self         = g_object_ref(self);
+    req->request_type = request_type;
+    req->detail       = g_strdup(detail);
+    req->subject      = g_object_ref(subject);
+    c_list_link_tail(&NM_AGENT_MANAGER_GET_PRIVATE(self)->request_lst_head, &req->request_lst);
+    return req;
 }
 
 static void
-request_free (Request *req)
+request_free(Request *req)
 {
-	switch (req->request_type) {
-	case REQUEST_TYPE_CON_GET:
-	case REQUEST_TYPE_CON_SAVE:
-	case REQUEST_TYPE_CON_DEL:
-		g_object_unref (req->con.connection);
-		g_free (req->con.path);
-		nm_clear_pointer (&req->con.chain, nm_auth_chain_destroy);
-		if (req->request_type == REQUEST_TYPE_CON_GET) {
-			g_free (req->con.get.setting_name);
-			g_strfreev (req->con.get.hints);
-			if (req->con.get.existing_secrets)
-				g_variant_unref (req->con.get.existing_secrets);
-		}
-		break;
-	default:
-		g_assert_not_reached ();
-	}
-
-	if (req->idle_id)
-		g_source_remove (req->idle_id);
-
-	/* cancel-secrets invokes the done-callback synchronously -- in which case
-	 * the handler just return.
-	 * Hence, we can proceed to free @req... */
-	nm_secret_agent_cancel_call (req->current, req->current_call_id);
-
-	g_object_unref (req->subject);
-
-	g_free (req->detail);
-	g_slist_free_full (req->pending, g_object_unref);
-
-	g_object_unref (req->self);
-
-	if (req->current)
-		g_object_unref (req->current);
-
-	memset (req, 0, sizeof (Request));
-	g_slice_free (Request, req);
+    switch (req->request_type) {
+    case REQUEST_TYPE_CON_GET:
+    case REQUEST_TYPE_CON_SAVE:
+    case REQUEST_TYPE_CON_DEL:
+        g_object_unref(req->con.connection);
+        g_free(req->con.path);
+        nm_clear_pointer(&req->con.chain, nm_auth_chain_destroy);
+        if (req->request_type == REQUEST_TYPE_CON_GET) {
+            g_free(req->con.get.setting_name);
+            g_strfreev(req->con.get.hints);
+            if (req->con.get.existing_secrets)
+                g_variant_unref(req->con.get.existing_secrets);
+        }
+        break;
+    default:
+        g_assert_not_reached();
+    }
+
+    if (req->idle_id)
+        g_source_remove(req->idle_id);
+
+    /* cancel-secrets invokes the done-callback synchronously -- in which case
+     * the handler just return.
+     * Hence, we can proceed to free @req... */
+    nm_secret_agent_cancel_call(req->current, req->current_call_id);
+
+    g_object_unref(req->subject);
+
+    g_free(req->detail);
+    g_slist_free_full(req->pending, g_object_unref);
+
+    g_object_unref(req->self);
+
+    if (req->current)
+        g_object_unref(req->current);
+
+    memset(req, 0, sizeof(Request));
+    g_slice_free(Request, req);
 }
 
 static void
-req_complete_release (Request *req,
-                      GVariant *secrets,
-                      const char *agent_dbus_owner,
-                      const char *agent_username,
-                     GError *error)
+req_complete_release(Request *   req,
+                     GVariant *  secrets,
+                     const char *agent_dbus_owner,
+                     const char *agent_username,
+                     GError *    error)
 {
-	NMAgentManager *self = req->self;
-
-	switch (req->request_type) {
-	case REQUEST_TYPE_CON_GET:
-		req->con.get.callback (self,
-		                       req,
-		                       agent_dbus_owner,
-		                       agent_username,
-		                       req->con.current_has_modify,
-		                       req->con.get.setting_name,
-		                       req->con.get.flags,
-		                       error ? NULL : secrets,
-		                       error,
-		                       req->con.get.callback_data);
-
-		break;
-	case REQUEST_TYPE_CON_SAVE:
-	case REQUEST_TYPE_CON_DEL:
-		break;
-	default:
-		g_return_if_reached ();
-	}
-
-	request_free (req);
+    NMAgentManager *self = req->self;
+
+    switch (req->request_type) {
+    case REQUEST_TYPE_CON_GET:
+        req->con.get.callback(self,
+                              req,
+                              agent_dbus_owner,
+                              agent_username,
+                              req->con.current_has_modify,
+                              req->con.get.setting_name,
+                              req->con.get.flags,
+                              error ? NULL : secrets,
+                              error,
+                              req->con.get.callback_data);
+
+        break;
+    case REQUEST_TYPE_CON_SAVE:
+    case REQUEST_TYPE_CON_DEL:
+        break;
+    default:
+        g_return_if_reached();
+    }
+
+    request_free(req);
 }
 
 static void
-req_complete_cancel (Request *req, gboolean is_disposing)
+req_complete_cancel(Request *req, gboolean is_disposing)
 {
-	gs_free_error GError *error = NULL;
+    gs_free_error GError *error = NULL;
 
-	nm_assert (req && req->self);
-	nm_assert (!c_list_contains (&NM_AGENT_MANAGER_GET_PRIVATE (req->self)->request_lst_head, &req->request_lst));
+    nm_assert(req && req->self);
+    nm_assert(!c_list_contains(&NM_AGENT_MANAGER_GET_PRIVATE(req->self)->request_lst_head,
+                               &req->request_lst));
 
-	nm_utils_error_set_cancelled (&error, is_disposing, "NMAgentManager");
-	req_complete_release (req, NULL, NULL, NULL, error);
+    nm_utils_error_set_cancelled(&error, is_disposing, "NMAgentManager");
+    req_complete_release(req, NULL, NULL, NULL, error);
 }
 
 static void
-req_complete (Request *req,
-              GVariant *secrets,
-              const char *agent_dbus_owner,
-              const char *agent_username,
-              GError *error)
+req_complete(Request *   req,
+             GVariant *  secrets,
+             const char *agent_dbus_owner,
+             const char *agent_username,
+             GError *    error)
 {
-	NMAgentManager *self = req->self;
+    NMAgentManager *self = req->self;
 
-	nm_assert (c_list_contains (&NM_AGENT_MANAGER_GET_PRIVATE (self)->request_lst_head, &req->request_lst));
+    nm_assert(
+        c_list_contains(&NM_AGENT_MANAGER_GET_PRIVATE(self)->request_lst_head, &req->request_lst));
 
-	c_list_unlink (&req->request_lst);
+    c_list_unlink(&req->request_lst);
 
-	req_complete_release (req, secrets, agent_dbus_owner, agent_username, error);
+    req_complete_release(req, secrets, agent_dbus_owner, agent_username, error);
 }
 
 static void
-req_complete_error (Request *req, GError *error)
+req_complete_error(Request *req, GError *error)
 {
-	req_complete (req, NULL, NULL, NULL, error);
+    req_complete(req, NULL, NULL, NULL, error);
 }
 
 static int
-agent_compare_func (gconstpointer aa, gconstpointer bb, gpointer user_data)
+agent_compare_func(gconstpointer aa, gconstpointer bb, gpointer user_data)
 {
-	NMSecretAgent *a = (NMSecretAgent *)aa;
-	NMSecretAgent *b = (NMSecretAgent *)bb;
-	Request *req = user_data;
-	NMSessionMonitor *sm;
-	gboolean a_active, b_active;
-	gulong a_pid, b_pid, requester;
-	guint64 a_start, b_start;
-
-	a_pid = nm_secret_agent_get_pid (a);
-	b_pid = nm_secret_agent_get_pid (b);
-
-	/* Prefer agents in the process the request came from */
-	if (nm_auth_subject_get_subject_type (req->subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS) {
-		requester = nm_auth_subject_get_unix_process_pid (req->subject);
-
-		if (a_pid != b_pid) {
-			if (a_pid == requester)
-				return -1;
-			else if (b_pid == requester)
-				return 1;
-		}
-	}
-
-	/* Prefer agents in active sessions */
-	sm = NM_AGENT_MANAGER_GET_PRIVATE (req->self)->session_monitor;
-	a_active = nm_session_monitor_session_exists (sm, nm_secret_agent_get_owner_uid (a), TRUE);
-	b_active = nm_session_monitor_session_exists (sm, nm_secret_agent_get_owner_uid (b), TRUE);
-	if (a_active && !b_active)
-		return -1;
-	else if (!a_active && b_active)
-		return 1;
-
-	/* Prefer agents launched later (this is essentially to ease agent debugging) */
-	a_start = nm_utils_get_start_time_for_pid (a_pid, NULL, NULL);
-	b_start = nm_utils_get_start_time_for_pid (b_pid, NULL, NULL);
-	if (a_start > b_start)
-		return -1;
-	else if (a_start < b_start)
-		return 1;
-
-	return 0;
+    NMSecretAgent *   a   = (NMSecretAgent *) aa;
+    NMSecretAgent *   b   = (NMSecretAgent *) bb;
+    Request *         req = user_data;
+    NMSessionMonitor *sm;
+    gboolean          a_active, b_active;
+    gulong            a_pid, b_pid, requester;
+    guint64           a_start, b_start;
+
+    a_pid = nm_secret_agent_get_pid(a);
+    b_pid = nm_secret_agent_get_pid(b);
+
+    /* Prefer agents in the process the request came from */
+    if (nm_auth_subject_get_subject_type(req->subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS) {
+        requester = nm_auth_subject_get_unix_process_pid(req->subject);
+
+        if (a_pid != b_pid) {
+            if (a_pid == requester)
+                return -1;
+            else if (b_pid == requester)
+                return 1;
+        }
+    }
+
+    /* Prefer agents in active sessions */
+    sm       = NM_AGENT_MANAGER_GET_PRIVATE(req->self)->session_monitor;
+    a_active = nm_session_monitor_session_exists(sm, nm_secret_agent_get_owner_uid(a), TRUE);
+    b_active = nm_session_monitor_session_exists(sm, nm_secret_agent_get_owner_uid(b), TRUE);
+    if (a_active && !b_active)
+        return -1;
+    else if (!a_active && b_active)
+        return 1;
+
+    /* Prefer agents launched later (this is essentially to ease agent debugging) */
+    a_start = nm_utils_get_start_time_for_pid(a_pid, NULL, NULL);
+    b_start = nm_utils_get_start_time_for_pid(b_pid, NULL, NULL);
+    if (a_start > b_start)
+        return -1;
+    else if (a_start < b_start)
+        return 1;
+
+    return 0;
 }
 
 static void
-request_add_agent (Request *req, NMSecretAgent *agent)
+request_add_agent(Request *req, NMSecretAgent *agent)
 {
-	NMAgentManager *self;
-
-	g_return_if_fail (req != NULL);
-	g_return_if_fail (agent != NULL);
-
-	self = req->self;
-
-	if (req->request_type == REQUEST_TYPE_CON_GET) {
-		NMAuthSubject *subject = nm_secret_agent_get_subject (agent);
-
-		/* Ensure the caller's username exists in the connection's permissions,
-		 * or that the permissions is empty (ie, visible by everyone).
-		 */
-		if (!nm_auth_is_subject_in_acl (req->con.connection, subject, NULL)) {
-			_LOGD (agent, "agent ignored for secrets request "LOG_REQ_FMT" (not in ACL)",
-			       LOG_REQ_ARG (req));
-			/* Connection not visible to this agent's user */
-			return;
-		}
-	}
-
-	/* If the request should filter agents by UID, do that now */
-	if (nm_auth_subject_get_subject_type (req->subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS) {
-		uid_t agent_uid, subject_uid;
-
-		agent_uid = nm_secret_agent_get_owner_uid (agent);
-		subject_uid = nm_auth_subject_get_unix_process_uid (req->subject);
-		if (agent_uid != subject_uid) {
-			_LOGD (agent, "agent ignored for secrets request "LOG_REQ_FMT" "
-			       "(uid %ld not required %ld)",
-			       LOG_REQ_ARG (req),
-			       (long) agent_uid, (long) subject_uid);
-			return;
-		}
-	}
-
-	_LOGD (agent, "agent allowed for secrets request "LOG_REQ_FMT,
-	       LOG_REQ_ARG (req));
-
-	/* Add this agent to the list, sorted appropriately */
-	req->pending = g_slist_insert_sorted_with_data (req->pending,
-	                                                g_object_ref (agent),
-	                                                agent_compare_func,
-	                                                req);
+    NMAgentManager *self;
+
+    g_return_if_fail(req != NULL);
+    g_return_if_fail(agent != NULL);
+
+    self = req->self;
+
+    if (req->request_type == REQUEST_TYPE_CON_GET) {
+        NMAuthSubject *subject = nm_secret_agent_get_subject(agent);
+
+        /* Ensure the caller's username exists in the connection's permissions,
+         * or that the permissions is empty (ie, visible by everyone).
+         */
+        if (!nm_auth_is_subject_in_acl(req->con.connection, subject, NULL)) {
+            _LOGD(agent,
+                  "agent ignored for secrets request " LOG_REQ_FMT " (not in ACL)",
+                  LOG_REQ_ARG(req));
+            /* Connection not visible to this agent's user */
+            return;
+        }
+    }
+
+    /* If the request should filter agents by UID, do that now */
+    if (nm_auth_subject_get_subject_type(req->subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS) {
+        uid_t agent_uid, subject_uid;
+
+        agent_uid   = nm_secret_agent_get_owner_uid(agent);
+        subject_uid = nm_auth_subject_get_unix_process_uid(req->subject);
+        if (agent_uid != subject_uid) {
+            _LOGD(agent,
+                  "agent ignored for secrets request " LOG_REQ_FMT " "
+                  "(uid %ld not required %ld)",
+                  LOG_REQ_ARG(req),
+                  (long) agent_uid,
+                  (long) subject_uid);
+            return;
+        }
+    }
+
+    _LOGD(agent, "agent allowed for secrets request " LOG_REQ_FMT, LOG_REQ_ARG(req));
+
+    /* Add this agent to the list, sorted appropriately */
+    req->pending =
+        g_slist_insert_sorted_with_data(req->pending, g_object_ref(agent), agent_compare_func, req);
 }
 
 static void
-request_add_agents (NMAgentManager *self, Request *req)
+request_add_agents(NMAgentManager *self, Request *req)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	NMSecretAgent *agent;
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    NMSecretAgent *        agent;
 
-	c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
-		if (agent->fully_registered)
-			request_add_agent (req, agent);
-	}
+    c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
+        if (agent->fully_registered)
+            request_add_agent(req, agent);
+    }
 }
 
 static void
-request_next_agent (Request *req)
+request_next_agent(Request *req)
 {
-	NMAgentManager *self;
-	GError *error = NULL;
-
-	self = req->self;
-
-	nm_secret_agent_cancel_call (req->current, req->current_call_id);
-	nm_assert (!req->current_call_id);
-	g_clear_object (&req->current);
-
-	if (req->pending) {
-		/* Send the request to the next agent */
-		req->current = req->pending->data;
-		req->pending = g_slist_remove (req->pending, req->current);
-
-		_LOGD (req->current, "agent %s secrets for request "LOG_REQ_FMT,
-		       _request_type_to_string (req->request_type, TRUE),
-		       LOG_REQ_ARG (req));
-
-		switch (req->request_type) {
-		case REQUEST_TYPE_CON_GET:
-			_con_get_request_start (req);
-			break;
-		case REQUEST_TYPE_CON_SAVE:
-			_con_save_request_start (req);
-			break;
-		case REQUEST_TYPE_CON_DEL:
-			_con_del_request_start (req);
-			break;
-		default:
-			g_assert_not_reached ();
-		}
-	} else {
-		/* No more secret agents are available to fulfill this secrets request */
-		error = g_error_new_literal (NM_AGENT_MANAGER_ERROR,
-		                             NM_AGENT_MANAGER_ERROR_NO_SECRETS,
-		                             "No agents were available for this request.");
-		req_complete_error (req, error);
-		g_error_free (error);
-	}
+    NMAgentManager *self;
+    GError *        error = NULL;
+
+    self = req->self;
+
+    nm_secret_agent_cancel_call(req->current, req->current_call_id);
+    nm_assert(!req->current_call_id);
+    g_clear_object(&req->current);
+
+    if (req->pending) {
+        /* Send the request to the next agent */
+        req->current = req->pending->data;
+        req->pending = g_slist_remove(req->pending, req->current);
+
+        _LOGD(req->current,
+              "agent %s secrets for request " LOG_REQ_FMT,
+              _request_type_to_string(req->request_type, TRUE),
+              LOG_REQ_ARG(req));
+
+        switch (req->request_type) {
+        case REQUEST_TYPE_CON_GET:
+            _con_get_request_start(req);
+            break;
+        case REQUEST_TYPE_CON_SAVE:
+            _con_save_request_start(req);
+            break;
+        case REQUEST_TYPE_CON_DEL:
+            _con_del_request_start(req);
+            break;
+        default:
+            g_assert_not_reached();
+        }
+    } else {
+        /* No more secret agents are available to fulfill this secrets request */
+        error = g_error_new_literal(NM_AGENT_MANAGER_ERROR,
+                                    NM_AGENT_MANAGER_ERROR_NO_SECRETS,
+                                    "No agents were available for this request.");
+        req_complete_error(req, error);
+        g_error_free(error);
+    }
 }
 
 static void
-request_remove_agent (Request *req, NMSecretAgent *agent)
+request_remove_agent(Request *req, NMSecretAgent *agent)
 {
-	NMAgentManager *self;
+    NMAgentManager *self;
 
-	g_return_if_fail (req != NULL);
-	g_return_if_fail (agent != NULL);
+    g_return_if_fail(req != NULL);
+    g_return_if_fail(agent != NULL);
 
-	self = req->self;
+    self = req->self;
 
-	if (agent == req->current) {
-		nm_assert (!g_slist_find (req->pending, agent));
+    if (agent == req->current) {
+        nm_assert(!g_slist_find(req->pending, agent));
 
-		_LOGD (agent, "current agent removed from secrets request "LOG_REQ_FMT,
-		       LOG_REQ_ARG (req));
+        _LOGD(agent, "current agent removed from secrets request " LOG_REQ_FMT, LOG_REQ_ARG(req));
 
-		switch (req->request_type) {
-		case REQUEST_TYPE_CON_GET:
-		case REQUEST_TYPE_CON_SAVE:
-		case REQUEST_TYPE_CON_DEL:
-			/* This cancels the pending authorization requests. */
-			nm_clear_pointer (&req->con.chain, nm_auth_chain_destroy);
-			break;
-		default:
-			g_assert_not_reached ();
-		}
+        switch (req->request_type) {
+        case REQUEST_TYPE_CON_GET:
+        case REQUEST_TYPE_CON_SAVE:
+        case REQUEST_TYPE_CON_DEL:
+            /* This cancels the pending authorization requests. */
+            nm_clear_pointer(&req->con.chain, nm_auth_chain_destroy);
+            break;
+        default:
+            g_assert_not_reached();
+        }
 
-		request_next_agent (req);
-	} else if (g_slist_find (req->pending, agent)) {
-		req->pending = g_slist_remove (req->pending, agent);
+        request_next_agent(req);
+    } else if (g_slist_find(req->pending, agent)) {
+        req->pending = g_slist_remove(req->pending, agent);
 
-		_LOGD (agent, "agent removed from secrets request "LOG_REQ_FMT,
-		       LOG_REQ_ARG (req));
+        _LOGD(agent, "agent removed from secrets request " LOG_REQ_FMT, LOG_REQ_ARG(req));
 
-		g_object_unref (agent);
-	}
+        g_object_unref(agent);
+    }
 }
 
 static gboolean
-request_start (gpointer user_data)
+request_start(gpointer user_data)
 {
-	Request *req = user_data;
+    Request *req = user_data;
 
-	req->idle_id = 0;
+    req->idle_id = 0;
 
-	switch (req->request_type) {
-	case REQUEST_TYPE_CON_GET:
-		if (_con_get_try_complete_early (req))
-			goto out;
-		break;
-	default:
-		break;
-	}
-	request_next_agent (req);
+    switch (req->request_type) {
+    case REQUEST_TYPE_CON_GET:
+        if (_con_get_try_complete_early(req))
+            goto out;
+        break;
+    default:
+        break;
+    }
+    request_next_agent(req);
 
 out:
-	return FALSE;
+    return FALSE;
 }
 
 /*****************************************************************************/
 
 static void
-_con_get_request_done (NMSecretAgent *agent,
-                       NMSecretAgentCallId *call_id,
-                       GVariant *secrets,
-                       GError *error,
-                       gpointer user_data)
+_con_get_request_done(NMSecretAgent *      agent,
+                      NMSecretAgentCallId *call_id,
+                      GVariant *           secrets,
+                      GError *             error,
+                      gpointer             user_data)
 {
-	NMAgentManager *self;
-	Request *req = user_data;
-	GVariant *setting_secrets;
-	const char *agent_dbus_owner;
-	struct passwd *pw;
-	char *agent_uname = NULL;
-
-	g_return_if_fail (call_id == req->current_call_id);
-	g_return_if_fail (agent == req->current);
-	g_return_if_fail (req->request_type == REQUEST_TYPE_CON_GET);
-
-	self = req->self;
-
-	req->current_call_id = NULL;
-
-	if (error) {
-		if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
-			_LOGD (agent, "get secrets request cancelled: "LOG_REQ_FMT,
-			       LOG_REQ_ARG (req));
-			return;
-		}
-
-		_LOGD (agent, "agent failed secrets request "LOG_REQ_FMT": %s",
-		       LOG_REQ_ARG (req),
-		       error->message);
-
-		if (g_error_matches (error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_USER_CANCELED)) {
-			error = g_error_new_literal (NM_AGENT_MANAGER_ERROR,
-			                             NM_AGENT_MANAGER_ERROR_USER_CANCELED,
-			                             "User canceled the secrets request.");
-			req_complete_error (req, error);
-			g_error_free (error);
-		} else {
-			/* Tell the failed agent we're no longer interested. */
-			nm_secret_agent_cancel_call (req->current, req->current_call_id);
-
-			/* Try the next agent */
-			request_next_agent (req);
-			maybe_remove_agent_on_error (self, agent, error);
-		}
-		return;
-	}
-
-	/* Ensure the setting we wanted secrets for got returned and has something in it */
-	setting_secrets = g_variant_lookup_value (secrets, req->con.get.setting_name, NM_VARIANT_TYPE_SETTING);
-	if (!setting_secrets || !g_variant_n_children (setting_secrets)) {
-		_LOGD (agent, "agent returned no secrets for request "LOG_REQ_FMT,
-		       LOG_REQ_ARG (req));
-		/* Try the next agent */
-		request_next_agent (req);
-		return;
-	}
-
-	_LOGD (agent, "agent returned secrets for request "LOG_REQ_FMT,
-	       LOG_REQ_ARG (req));
-
-	/* Get the agent's username */
-	pw = getpwuid (nm_secret_agent_get_owner_uid (agent));
-	if (pw && strlen (pw->pw_name)) {
-		/* Needs to be UTF-8 valid since it may be pushed through D-Bus */
-		if (g_utf8_validate (pw->pw_name, -1, NULL))
-			agent_uname = g_strdup (pw->pw_name);
-	}
-
-	agent_dbus_owner = nm_secret_agent_get_dbus_owner (agent);
-	req_complete (req, secrets, agent_dbus_owner, agent_uname, NULL);
-	g_free (agent_uname);
+    NMAgentManager *self;
+    Request *       req = user_data;
+    GVariant *      setting_secrets;
+    const char *    agent_dbus_owner;
+    gs_free char *  agent_name = NULL;
+
+    g_return_if_fail(call_id == req->current_call_id);
+    g_return_if_fail(agent == req->current);
+    g_return_if_fail(req->request_type == REQUEST_TYPE_CON_GET);
+
+    self = req->self;
+
+    req->current_call_id = NULL;
+
+    if (error) {
+        if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+            _LOGD(agent, "get secrets request cancelled: " LOG_REQ_FMT, LOG_REQ_ARG(req));
+            return;
+        }
+
+        _LOGD(agent,
+              "agent failed secrets request " LOG_REQ_FMT ": %s",
+              LOG_REQ_ARG(req),
+              error->message);
+
+        if (g_error_matches(error, NM_SECRET_AGENT_ERROR, NM_SECRET_AGENT_ERROR_USER_CANCELED)) {
+            error = g_error_new_literal(NM_AGENT_MANAGER_ERROR,
+                                        NM_AGENT_MANAGER_ERROR_USER_CANCELED,
+                                        "User canceled the secrets request.");
+            req_complete_error(req, error);
+            g_error_free(error);
+        } else {
+            /* Tell the failed agent we're no longer interested. */
+            nm_secret_agent_cancel_call(req->current, req->current_call_id);
+
+            /* Try the next agent */
+            request_next_agent(req);
+            maybe_remove_agent_on_error(self, agent, error);
+        }
+        return;
+    }
+
+    /* Ensure the setting we wanted secrets for got returned and has something in it */
+    setting_secrets =
+        g_variant_lookup_value(secrets, req->con.get.setting_name, NM_VARIANT_TYPE_SETTING);
+    if (!setting_secrets || !g_variant_n_children(setting_secrets)) {
+        _LOGD(agent, "agent returned no secrets for request " LOG_REQ_FMT, LOG_REQ_ARG(req));
+        /* Try the next agent */
+        request_next_agent(req);
+        return;
+    }
+
+    _LOGD(agent, "agent returned secrets for request " LOG_REQ_FMT, LOG_REQ_ARG(req));
+
+    agent_name = nm_utils_uid_to_name(nm_secret_agent_get_owner_uid(agent));
+    if (agent_name && !g_utf8_validate(agent_name, -1, NULL)) {
+        /* Needs to be UTF-8 valid since it may be pushed through D-Bus */
+        nm_clear_g_free(&agent_name);
+    }
+
+    agent_dbus_owner = nm_secret_agent_get_dbus_owner(agent);
+
+    req_complete(req, secrets, agent_dbus_owner, agent_name, NULL);
 }
 
 static void
-set_secrets_not_required (NMConnection *connection, GVariant *dict)
+set_secrets_not_required(NMConnection *connection, GVariant *dict)
 {
-	GVariantIter iter, setting_iter;
-	const char *setting_name = NULL;
-	GVariant *setting_dict = NULL;
-
-	/* Iterate through the settings dicts */
-	g_variant_iter_init (&iter, dict);
-	while (g_variant_iter_next (&iter, "{&s@a{sv}}", &setting_name, &setting_dict)) {
-		const char *key_name = NULL;
-		NMSetting *setting;
-		GVariant *val;
-
-		setting = nm_connection_get_setting_by_name (connection, setting_name);
-		if (setting) {
-			/* Now through each secret in the setting and mark it as not required */
-			g_variant_iter_init (&setting_iter, setting_dict);
-			while (g_variant_iter_next (&setting_iter, "{&sv}", &key_name, &val)) {
-				/* For each secret, set the flag that it's not required; VPN
-				 * secrets need slightly different treatment here since the
-				 * "secrets" property is actually a dictionary of secrets.
-				 */
-				if (   strcmp (setting_name, NM_SETTING_VPN_SETTING_NAME) == 0
-				    && strcmp (key_name, NM_SETTING_VPN_SECRETS) == 0
-				    && g_variant_is_of_type (val, G_VARIANT_TYPE ("a{ss}"))) {
-					GVariantIter vpn_secret_iter;
-					const char *secret_name, *secret;
-
-					g_variant_iter_init (&vpn_secret_iter, val);
-					while (g_variant_iter_next (&vpn_secret_iter, "{&s&s}", &secret_name, &secret))
-						nm_setting_set_secret_flags (setting, secret_name, NM_SETTING_SECRET_FLAG_NOT_REQUIRED, NULL);
-				} else
-					nm_setting_set_secret_flags (setting, key_name, NM_SETTING_SECRET_FLAG_NOT_REQUIRED, NULL);
-				g_variant_unref (val);
-			}
-		}
-		g_variant_unref (setting_dict);
-	}
+    GVariantIter iter, setting_iter;
+    const char * setting_name = NULL;
+    GVariant *   setting_dict = NULL;
+
+    /* Iterate through the settings dicts */
+    g_variant_iter_init(&iter, dict);
+    while (g_variant_iter_next(&iter, "{&s@a{sv}}", &setting_name, &setting_dict)) {
+        const char *key_name = NULL;
+        NMSetting * setting;
+        GVariant *  val;
+
+        setting = nm_connection_get_setting_by_name(connection, setting_name);
+        if (setting) {
+            /* Now through each secret in the setting and mark it as not required */
+            g_variant_iter_init(&setting_iter, setting_dict);
+            while (g_variant_iter_next(&setting_iter, "{&sv}", &key_name, &val)) {
+                /* For each secret, set the flag that it's not required; VPN
+                 * secrets need slightly different treatment here since the
+                 * "secrets" property is actually a dictionary of secrets.
+                 */
+                if (strcmp(setting_name, NM_SETTING_VPN_SETTING_NAME) == 0
+                    && strcmp(key_name, NM_SETTING_VPN_SECRETS) == 0
+                    && g_variant_is_of_type(val, G_VARIANT_TYPE("a{ss}"))) {
+                    GVariantIter vpn_secret_iter;
+                    const char * secret_name, *secret;
+
+                    g_variant_iter_init(&vpn_secret_iter, val);
+                    while (g_variant_iter_next(&vpn_secret_iter, "{&s&s}", &secret_name, &secret))
+                        nm_setting_set_secret_flags(setting,
+                                                    secret_name,
+                                                    NM_SETTING_SECRET_FLAG_NOT_REQUIRED,
+                                                    NULL);
+                } else
+                    nm_setting_set_secret_flags(setting,
+                                                key_name,
+                                                NM_SETTING_SECRET_FLAG_NOT_REQUIRED,
+                                                NULL);
+                g_variant_unref(val);
+            }
+        }
+        g_variant_unref(setting_dict);
+    }
 }
 
 static void
-_con_get_request_start_proceed (Request *req, gboolean include_system_secrets)
+_con_get_request_start_proceed(Request *req, gboolean include_system_secrets)
 {
-	NMConnection *tmp;
-
-	g_return_if_fail (req->request_type == REQUEST_TYPE_CON_GET);
-
-	tmp = nm_simple_connection_new_clone (req->con.connection);
-	nm_connection_clear_secrets (tmp);
-	if (include_system_secrets) {
-		if (req->con.get.existing_secrets)
-			(void) nm_connection_update_secrets (tmp, req->con.get.setting_name, req->con.get.existing_secrets, NULL);
-	} else {
-		/* Update secret flags in the temporary connection to indicate that
-		 * the system secrets we're not sending to the agent aren't required,
-		 * so the agent can properly validate UI controls and such.
-		 */
-		if (req->con.get.existing_secrets)
-			set_secrets_not_required (tmp, req->con.get.existing_secrets);
-	}
-
-	req->current_call_id = nm_secret_agent_get_secrets (req->current,
-	                                                    req->con.path,
-	                                                    tmp,
-	                                                    req->con.get.setting_name,
-	                                                    (const char **) req->con.get.hints,
-	                                                    req->con.get.flags,
-	                                                    _con_get_request_done,
-	                                                    req);
-	if (!req->current_call_id) {
-		g_warn_if_reached ();
-		request_next_agent (req);
-	}
-
-	g_object_unref (tmp);
+    NMConnection *tmp;
+
+    g_return_if_fail(req->request_type == REQUEST_TYPE_CON_GET);
+
+    tmp = nm_simple_connection_new_clone(req->con.connection);
+    nm_connection_clear_secrets(tmp);
+    if (include_system_secrets) {
+        if (req->con.get.existing_secrets)
+            (void) nm_connection_update_secrets(tmp,
+                                                req->con.get.setting_name,
+                                                req->con.get.existing_secrets,
+                                                NULL);
+    } else {
+        /* Update secret flags in the temporary connection to indicate that
+         * the system secrets we're not sending to the agent aren't required,
+         * so the agent can properly validate UI controls and such.
+         */
+        if (req->con.get.existing_secrets)
+            set_secrets_not_required(tmp, req->con.get.existing_secrets);
+    }
+
+    req->current_call_id = nm_secret_agent_get_secrets(req->current,
+                                                       req->con.path,
+                                                       tmp,
+                                                       req->con.get.setting_name,
+                                                       (const char **) req->con.get.hints,
+                                                       req->con.get.flags,
+                                                       _con_get_request_done,
+                                                       req);
+    if (!req->current_call_id) {
+        g_warn_if_reached();
+        request_next_agent(req);
+    }
+
+    g_object_unref(tmp);
 }
 
 static void
-_con_get_request_start_validated (NMAuthChain *chain,
+_con_get_request_start_validated(NMAuthChain *          chain,
                                  GDBusMethodInvocation *context,
-                                 gpointer user_data)
+                                 gpointer               user_data)
 {
-	NMAgentManager *self;
-	Request *req = user_data;
-	const char *perm;
+    NMAgentManager *self;
+    Request *       req = user_data;
+    const char *    perm;
 
-	g_return_if_fail (req->request_type == REQUEST_TYPE_CON_GET);
+    g_return_if_fail(req->request_type == REQUEST_TYPE_CON_GET);
 
-	self = req->self;
+    self = req->self;
 
-	req->con.chain = NULL;
+    req->con.chain = NULL;
 
-	/* If the agent obtained the 'modify' permission, we send all system secrets
-	 * to it.  If it didn't, we still ask it for secrets, but we don't send
-	 * any system secrets.
-	 */
-	perm = nm_auth_chain_get_data (chain, "perm");
-	g_assert (perm);
-	if (nm_auth_chain_get_result (chain, perm) == NM_AUTH_CALL_RESULT_YES)
-		req->con.current_has_modify = TRUE;
+    /* If the agent obtained the 'modify' permission, we send all system secrets
+     * to it.  If it didn't, we still ask it for secrets, but we don't send
+     * any system secrets.
+     */
+    perm = nm_auth_chain_get_data(chain, "perm");
+    g_assert(perm);
+    if (nm_auth_chain_get_result(chain, perm) == NM_AUTH_CALL_RESULT_YES)
+        req->con.current_has_modify = TRUE;
 
-	_LOGD (req->current, "agent "LOG_REQ_FMT" MODIFY check result %s",
-	       LOG_REQ_ARG (req),
-	       req->con.current_has_modify ? "YES" : "NO");
+    _LOGD(req->current,
+          "agent " LOG_REQ_FMT " MODIFY check result %s",
+          LOG_REQ_ARG(req),
+          req->con.current_has_modify ? "YES" : "NO");
 
-	_con_get_request_start_proceed (req, req->con.current_has_modify);
+    _con_get_request_start_proceed(req, req->con.current_has_modify);
 }
 
 static void
-_con_get_request_start (Request *req)
+_con_get_request_start(Request *req)
 {
-	NMAgentManager *self;
-	NMSettingConnection *s_con;
-	const char *agent_dbus_owner, *perm;
-
-	self = req->self;
-
-	req->con.current_has_modify = FALSE;
-
-	agent_dbus_owner = nm_secret_agent_get_dbus_owner (req->current);
-
-	/* If the request flags allow user interaction, and there are existing
-	 * system secrets (or blank secrets that are supposed to be system-owned),
-	 * check whether the agent has the 'modify' permission before sending those
-	 * secrets to the agent.  We shouldn't leak system-owned secrets to
-	 * unprivileged users.
-	 */
-	if (   (req->con.get.flags != NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE)
-	    && (   req->con.get.existing_secrets
-	        || _nm_connection_aggregate (req->con.connection, NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS, NULL))) {
-		_LOGD (NULL, "("LOG_REQ_FMT") request has system secrets; checking agent %s for MODIFY",
-		       LOG_REQ_ARG (req), agent_dbus_owner);
-
-		req->con.chain = nm_auth_chain_new_subject (nm_secret_agent_get_subject (req->current),
-		                                            NULL,
-		                                            _con_get_request_start_validated,
-		                                            req);
-		nm_assert (req->con.chain);
-
-		/* If the caller is the only user in the connection's permissions, then
-		 * we use the 'modify.own' permission instead of 'modify.system'.  If the
-		 * request affects more than just the caller, require 'modify.system'.
-		 */
-		s_con = nm_connection_get_setting_connection (req->con.connection);
-		g_assert (s_con);
-		if (nm_setting_connection_get_num_permissions (s_con) == 1)
-			perm = NM_AUTH_PERMISSION_SETTINGS_MODIFY_OWN;
-		else
-			perm = NM_AUTH_PERMISSION_SETTINGS_MODIFY_SYSTEM;
-		nm_auth_chain_set_data (req->con.chain, "perm", (gpointer) perm, NULL);
-
-		nm_auth_chain_add_call_unsafe (req->con.chain, perm, TRUE);
-	} else {
-		_LOGD (NULL, "("LOG_REQ_FMT") requesting user-owned secrets from agent %s",
-		       LOG_REQ_ARG (req), agent_dbus_owner);
-
-		_con_get_request_start_proceed (req, FALSE);
-	}
+    NMAgentManager *     self;
+    NMSettingConnection *s_con;
+    const char *         agent_dbus_owner, *perm;
+
+    self = req->self;
+
+    req->con.current_has_modify = FALSE;
+
+    agent_dbus_owner = nm_secret_agent_get_dbus_owner(req->current);
+
+    /* If the request flags allow user interaction, and there are existing
+     * system secrets (or blank secrets that are supposed to be system-owned),
+     * check whether the agent has the 'modify' permission before sending those
+     * secrets to the agent.  We shouldn't leak system-owned secrets to
+     * unprivileged users.
+     */
+    if ((req->con.get.flags != NM_SECRET_AGENT_GET_SECRETS_FLAG_NONE)
+        && (req->con.get.existing_secrets
+            || _nm_connection_aggregate(req->con.connection,
+                                        NM_CONNECTION_AGGREGATE_ANY_SYSTEM_SECRET_FLAGS,
+                                        NULL))) {
+        _LOGD(NULL,
+              "(" LOG_REQ_FMT ") request has system secrets; checking agent %s for MODIFY",
+              LOG_REQ_ARG(req),
+              agent_dbus_owner);
+
+        req->con.chain = nm_auth_chain_new_subject(nm_secret_agent_get_subject(req->current),
+                                                   NULL,
+                                                   _con_get_request_start_validated,
+                                                   req);
+        nm_assert(req->con.chain);
+
+        /* If the caller is the only user in the connection's permissions, then
+         * we use the 'modify.own' permission instead of 'modify.system'.  If the
+         * request affects more than just the caller, require 'modify.system'.
+         */
+        s_con = nm_connection_get_setting_connection(req->con.connection);
+        g_assert(s_con);
+        if (nm_setting_connection_get_num_permissions(s_con) == 1)
+            perm = NM_AUTH_PERMISSION_SETTINGS_MODIFY_OWN;
+        else
+            perm = NM_AUTH_PERMISSION_SETTINGS_MODIFY_SYSTEM;
+        nm_auth_chain_set_data(req->con.chain, "perm", (gpointer) perm, NULL);
+
+        nm_auth_chain_add_call_unsafe(req->con.chain, perm, TRUE);
+    } else {
+        _LOGD(NULL,
+              "(" LOG_REQ_FMT ") requesting user-owned secrets from agent %s",
+              LOG_REQ_ARG(req),
+              agent_dbus_owner);
+
+        _con_get_request_start_proceed(req, FALSE);
+    }
 }
 
 static gboolean
-_con_get_try_complete_early (Request *req)
+_con_get_try_complete_early(Request *req)
 {
-	NMAgentManager *self;
-	gs_unref_variant GVariant *setting_secrets = NULL;
-	gs_unref_object NMConnection *tmp = NULL;
-	GError *error = NULL;
-
-	self = req->self;
-
-	/* Check if there are any existing secrets */
-	if (req->con.get.existing_secrets)
-		setting_secrets = g_variant_lookup_value (req->con.get.existing_secrets, req->con.get.setting_name, NM_VARIANT_TYPE_SETTING);
-
-	if (!setting_secrets || !g_variant_n_children (setting_secrets))
-		return FALSE;
-
-	/* The connection already had secrets; check if any more are required.
-	 * If no more are required, we're done.  If secrets are still needed,
-	 * ask a secret agent for more.  This allows admins to provide generic
-	 * secrets but allow additional user-specific ones as well.
-	 */
-	tmp = nm_simple_connection_new_clone (req->con.connection);
-	g_assert (tmp);
-
-	if (!nm_connection_update_secrets (tmp, req->con.get.setting_name, req->con.get.existing_secrets, &error)) {
-		req_complete_error (req, error);
-		g_clear_error (&error);
-		return TRUE;
-	}
-	/* Do we have everything we need? */
-	if (   NM_FLAGS_HAS (req->con.get.flags, NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM)
-	    || (   (nm_connection_need_secrets (tmp, NULL) == NULL)
-	        && !NM_FLAGS_HAS(req->con.get.flags, NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW))) {
-		_LOGD (NULL, "("LOG_REQ_FMT") system settings secrets sufficient",
-		       LOG_REQ_ARG (req));
-
-		/* Got everything, we're done */
-		req_complete (req, req->con.get.existing_secrets, NULL, NULL, NULL);
-		return TRUE;
-	}
-
-	_LOGD (NULL, "("LOG_REQ_FMT") system settings secrets insufficient, asking agents",
-	       LOG_REQ_ARG (req));
-
-	/* We don't, so ask some agents for additional secrets */
-	if (   req->con.get.flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS
-	    && !req->pending) {
-		/* The request initiated from GetSecrets() via DBus,
-		 * don't error out if any secrets are missing. */
-		req_complete (req, req->con.get.existing_secrets, NULL, NULL, NULL);
-		return TRUE;
-	}
-
-	/* Couldn't get secrets from system settings, so now we ask the
-	 * agents for secrets.  Let the Agent Manager handle which agents
-	 * we'll ask and in which order.
-	 */
-	return FALSE;
+    NMAgentManager * self;
+    gs_unref_variant GVariant *setting_secrets = NULL;
+    gs_unref_object NMConnection *tmp          = NULL;
+    GError *                      error        = NULL;
+
+    self = req->self;
+
+    /* Check if there are any existing secrets */
+    if (req->con.get.existing_secrets)
+        setting_secrets = g_variant_lookup_value(req->con.get.existing_secrets,
+                                                 req->con.get.setting_name,
+                                                 NM_VARIANT_TYPE_SETTING);
+
+    if (!setting_secrets || !g_variant_n_children(setting_secrets))
+        return FALSE;
+
+    /* The connection already had secrets; check if any more are required.
+     * If no more are required, we're done.  If secrets are still needed,
+     * ask a secret agent for more.  This allows admins to provide generic
+     * secrets but allow additional user-specific ones as well.
+     */
+    tmp = nm_simple_connection_new_clone(req->con.connection);
+    g_assert(tmp);
+
+    if (!nm_connection_update_secrets(tmp,
+                                      req->con.get.setting_name,
+                                      req->con.get.existing_secrets,
+                                      &error)) {
+        req_complete_error(req, error);
+        g_clear_error(&error);
+        return TRUE;
+    }
+    /* Do we have everything we need? */
+    if (NM_FLAGS_HAS(req->con.get.flags, NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM)
+        || ((nm_connection_need_secrets(tmp, NULL) == NULL)
+            && !NM_FLAGS_HAS(req->con.get.flags, NM_SECRET_AGENT_GET_SECRETS_FLAG_REQUEST_NEW))) {
+        _LOGD(NULL, "(" LOG_REQ_FMT ") system settings secrets sufficient", LOG_REQ_ARG(req));
+
+        /* Got everything, we're done */
+        req_complete(req, req->con.get.existing_secrets, NULL, NULL, NULL);
+        return TRUE;
+    }
+
+    _LOGD(NULL,
+          "(" LOG_REQ_FMT ") system settings secrets insufficient, asking agents",
+          LOG_REQ_ARG(req));
+
+    /* We don't, so ask some agents for additional secrets */
+    if (req->con.get.flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_NO_ERRORS && !req->pending) {
+        /* The request initiated from GetSecrets() via DBus,
+         * don't error out if any secrets are missing. */
+        req_complete(req, req->con.get.existing_secrets, NULL, NULL, NULL);
+        return TRUE;
+    }
+
+    /* Couldn't get secrets from system settings, so now we ask the
+     * agents for secrets.  Let the Agent Manager handle which agents
+     * we'll ask and in which order.
+     */
+    return FALSE;
 }
 
 /**
@@ -1171,425 +1215,404 @@ _con_get_try_complete_early (Request *req)
  * Requests secrets for a connection.
  *
  * This function cannot fail. The callback will be invoked
- * asynchrnously, but it will always be invoked exactly once.
+ * asynchronously, but it will always be invoked exactly once.
  * Even for cancellation and disposing of @self. In those latter
- * cases, the callback is invoked synchrnously during the cancellation/
+ * cases, the callback is invoked synchronously during the cancellation/
  * disposal.
  *
  * Returns: a call-id to cancel the call.
  */
 NMAgentManagerCallId
-nm_agent_manager_get_secrets (NMAgentManager *self,
-                              const char *path,
-                              NMConnection *connection,
-                              NMAuthSubject *subject,
-                              GVariant *existing_secrets,
-                              const char *setting_name,
-                              NMSecretAgentGetSecretsFlags flags,
-                              const char *const*hints,
-                              NMAgentSecretsResultFunc callback,
-                              gpointer callback_data)
+nm_agent_manager_get_secrets(NMAgentManager *             self,
+                             const char *                 path,
+                             NMConnection *               connection,
+                             NMAuthSubject *              subject,
+                             GVariant *                   existing_secrets,
+                             const char *                 setting_name,
+                             NMSecretAgentGetSecretsFlags flags,
+                             const char *const *          hints,
+                             NMAgentSecretsResultFunc     callback,
+                             gpointer                     callback_data)
 {
-	Request *req;
-
-	g_return_val_if_fail (self != NULL, NULL);
-	g_return_val_if_fail (path && *path, NULL);
-	g_return_val_if_fail (NM_IS_CONNECTION (connection), NULL);
-	g_return_val_if_fail (callback != NULL, NULL);
-
-	nm_log_dbg (LOGD_SETTINGS,
-	            "Secrets requested for connection %s (%s/%s)",
-	            path,
-	            nm_connection_get_id (connection),
-	            setting_name);
-
-	/* NOTE: a few things in the Request handling depend on existing_secrets
-	 * being NULL if there aren't any system-owned secrets for this connection.
-	 * This in turn depends on nm_connection_to_dbus() and nm_setting_to_hash()
-	 * both returning NULL if they didn't hash anything.
-	 */
-	req = request_new (self,
-	                   REQUEST_TYPE_CON_GET,
-	                   nm_connection_get_id (connection),
-	                   subject);
-
-	req->con.path = g_strdup (path);
-	req->con.connection = g_object_ref (connection);
-	if (existing_secrets)
-		req->con.get.existing_secrets = g_variant_ref (existing_secrets);
-	req->con.get.setting_name = g_strdup (setting_name);
-	req->con.get.hints = g_strdupv ((char **) hints);
-	req->con.get.flags = flags;
-	req->con.get.callback = callback;
-	req->con.get.callback_data = callback_data;
-
-	if (!(req->con.get.flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM))
-		request_add_agents (self, req);
-	req->idle_id = g_idle_add (request_start, req);
-	return req;
+    Request *req;
+
+    g_return_val_if_fail(self != NULL, NULL);
+    g_return_val_if_fail(path && *path, NULL);
+    g_return_val_if_fail(NM_IS_CONNECTION(connection), NULL);
+    g_return_val_if_fail(callback != NULL, NULL);
+
+    nm_log_dbg(LOGD_SETTINGS,
+               "Secrets requested for connection %s (%s/%s)",
+               path,
+               nm_connection_get_id(connection),
+               setting_name);
+
+    /* NOTE: a few things in the Request handling depend on existing_secrets
+     * being NULL if there aren't any system-owned secrets for this connection.
+     * This in turn depends on nm_connection_to_dbus() and nm_setting_to_hash()
+     * both returning NULL if they didn't hash anything.
+     */
+    req = request_new(self, REQUEST_TYPE_CON_GET, nm_connection_get_id(connection), subject);
+
+    req->con.path       = g_strdup(path);
+    req->con.connection = g_object_ref(connection);
+    if (existing_secrets)
+        req->con.get.existing_secrets = g_variant_ref(existing_secrets);
+    req->con.get.setting_name  = g_strdup(setting_name);
+    req->con.get.hints         = g_strdupv((char **) hints);
+    req->con.get.flags         = flags;
+    req->con.get.callback      = callback;
+    req->con.get.callback_data = callback_data;
+
+    if (!(req->con.get.flags & NM_SECRET_AGENT_GET_SECRETS_FLAG_ONLY_SYSTEM))
+        request_add_agents(self, req);
+    req->idle_id = g_idle_add(request_start, req);
+    return req;
 }
 
 void
-nm_agent_manager_cancel_secrets (NMAgentManager *self,
-                                 NMAgentManagerCallId request_id)
+nm_agent_manager_cancel_secrets(NMAgentManager *self, NMAgentManagerCallId request_id)
 {
-	g_return_if_fail (self != NULL);
-	g_return_if_fail (request_id);
-	g_return_if_fail (request_id->request_type == REQUEST_TYPE_CON_GET);
+    g_return_if_fail(self != NULL);
+    g_return_if_fail(request_id);
+    g_return_if_fail(request_id->request_type == REQUEST_TYPE_CON_GET);
 
-	nm_assert (c_list_contains (&NM_AGENT_MANAGER_GET_PRIVATE (self)->request_lst_head, &request_id->request_lst));
+    nm_assert(c_list_contains(&NM_AGENT_MANAGER_GET_PRIVATE(self)->request_lst_head,
+                              &request_id->request_lst));
 
-	c_list_unlink (&request_id->request_lst);
+    c_list_unlink(&request_id->request_lst);
 
-	req_complete_cancel (request_id, FALSE);
+    req_complete_cancel(request_id, FALSE);
 }
 
 /*****************************************************************************/
 
 static void
-_con_save_request_done (NMSecretAgent *agent,
-                        NMSecretAgentCallId *call_id,
-                        GVariant *secrets,
-                        GError *error,
-                        gpointer user_data)
+_con_save_request_done(NMSecretAgent *      agent,
+                       NMSecretAgentCallId *call_id,
+                       GVariant *           secrets,
+                       GError *             error,
+                       gpointer             user_data)
 {
-	NMAgentManager *self;
-	Request *req = user_data;
-	const char *agent_dbus_owner;
-
-	g_return_if_fail (call_id == req->current_call_id);
-	g_return_if_fail (agent == req->current);
-	g_return_if_fail (req->request_type == REQUEST_TYPE_CON_SAVE);
-
-	self = req->self;
-
-	req->current_call_id = NULL;
-
-	if (error) {
-		if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
-			_LOGD (agent, "save secrets request cancelled: "LOG_REQ_FMT,
-			       LOG_REQ_ARG (req));
-			return;
-		}
-
-		_LOGD (agent, "agent failed save secrets request "LOG_REQ_FMT": %s",
-		       LOG_REQ_ARG (req), error->message);
-		/* Try the next agent */
-		request_next_agent (req);
-		maybe_remove_agent_on_error (self, agent, error);
-		return;
-	}
-
-	_LOGD (agent, "agent saved secrets for request "LOG_REQ_FMT,
-	       LOG_REQ_ARG (req));
-
-	agent_dbus_owner = nm_secret_agent_get_dbus_owner (agent);
-	req_complete (req, NULL, NULL, agent_dbus_owner, NULL);
+    NMAgentManager *self;
+    Request *       req = user_data;
+    const char *    agent_dbus_owner;
+
+    g_return_if_fail(call_id == req->current_call_id);
+    g_return_if_fail(agent == req->current);
+    g_return_if_fail(req->request_type == REQUEST_TYPE_CON_SAVE);
+
+    self = req->self;
+
+    req->current_call_id = NULL;
+
+    if (error) {
+        if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+            _LOGD(agent, "save secrets request cancelled: " LOG_REQ_FMT, LOG_REQ_ARG(req));
+            return;
+        }
+
+        _LOGD(agent,
+              "agent failed save secrets request " LOG_REQ_FMT ": %s",
+              LOG_REQ_ARG(req),
+              error->message);
+        /* Try the next agent */
+        request_next_agent(req);
+        maybe_remove_agent_on_error(self, agent, error);
+        return;
+    }
+
+    _LOGD(agent, "agent saved secrets for request " LOG_REQ_FMT, LOG_REQ_ARG(req));
+
+    agent_dbus_owner = nm_secret_agent_get_dbus_owner(agent);
+    req_complete(req, NULL, NULL, agent_dbus_owner, NULL);
 }
 
 static void
-_con_save_request_start (Request *req)
+_con_save_request_start(Request *req)
 {
-	req->current_call_id = nm_secret_agent_save_secrets (req->current,
-	                                                     req->con.path,
-	                                                     req->con.connection,
-	                                                     _con_save_request_done,
-	                                                     req);
-	if (!req->current_call_id) {
-		g_warn_if_reached ();
-		request_next_agent (req);
-	}
+    req->current_call_id = nm_secret_agent_save_secrets(req->current,
+                                                        req->con.path,
+                                                        req->con.connection,
+                                                        _con_save_request_done,
+                                                        req);
+    if (!req->current_call_id) {
+        g_warn_if_reached();
+        request_next_agent(req);
+    }
 }
 
 void
-nm_agent_manager_save_secrets (NMAgentManager *self,
-                               const char *path,
-                               NMConnection *connection,
-                               NMAuthSubject *subject)
+nm_agent_manager_save_secrets(NMAgentManager *self,
+                              const char *    path,
+                              NMConnection *  connection,
+                              NMAuthSubject * subject)
 {
-	Request *req;
-
-	g_return_if_fail (self);
-	g_return_if_fail (path && *path);
-	g_return_if_fail (NM_IS_CONNECTION (connection));
-
-	nm_log_dbg (LOGD_SETTINGS,
-	            "Saving secrets for connection %s (%s)",
-	            path,
-	            nm_connection_get_id (connection));
-
-	req = request_new (self,
-	                   REQUEST_TYPE_CON_SAVE,
-	                   nm_connection_get_id (connection),
-	                   subject);
-	req->con.path = g_strdup (path);
-	req->con.connection = g_object_ref (connection);
-
-	request_add_agents (self, req);
-	req->idle_id = g_idle_add (request_start, req);
+    Request *req;
+
+    g_return_if_fail(self);
+    g_return_if_fail(path && *path);
+    g_return_if_fail(NM_IS_CONNECTION(connection));
+
+    nm_log_dbg(LOGD_SETTINGS,
+               "Saving secrets for connection %s (%s)",
+               path,
+               nm_connection_get_id(connection));
+
+    req = request_new(self, REQUEST_TYPE_CON_SAVE, nm_connection_get_id(connection), subject);
+    req->con.path       = g_strdup(path);
+    req->con.connection = g_object_ref(connection);
+
+    request_add_agents(self, req);
+    req->idle_id = g_idle_add(request_start, req);
 }
 
 /*****************************************************************************/
 
 static void
-_con_del_request_done (NMSecretAgent *agent,
-                       NMSecretAgentCallId *call_id,
-                       GVariant *secrets,
-                       GError *error,
-                       gpointer user_data)
+_con_del_request_done(NMSecretAgent *      agent,
+                      NMSecretAgentCallId *call_id,
+                      GVariant *           secrets,
+                      GError *             error,
+                      gpointer             user_data)
 {
-	NMAgentManager *self;
-	Request *req = user_data;
-
-	g_return_if_fail (call_id == req->current_call_id);
-	g_return_if_fail (agent == req->current);
-	g_return_if_fail (req->request_type == REQUEST_TYPE_CON_DEL);
-
-	self = req->self;
-
-	req->current_call_id = NULL;
-
-	if (error) {
-		if (g_error_matches (error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
-			_LOGD (agent, "delete secrets request cancelled: "LOG_REQ_FMT,
-			       LOG_REQ_ARG (req));
-			return;
-		}
-
-		_LOGD (agent, "agent failed delete secrets request "LOG_REQ_FMT": %s",
-		       LOG_REQ_ARG (req), error->message);
-	} else {
-		_LOGD (agent, "agent deleted secrets for request "LOG_REQ_FMT,
-		       LOG_REQ_ARG (req));
-	}
-
-	/* Tell the next agent to delete secrets */
-	request_next_agent (req);
-	if (error)
-		maybe_remove_agent_on_error (self, agent, error);
+    NMAgentManager *self;
+    Request *       req = user_data;
+
+    g_return_if_fail(call_id == req->current_call_id);
+    g_return_if_fail(agent == req->current);
+    g_return_if_fail(req->request_type == REQUEST_TYPE_CON_DEL);
+
+    self = req->self;
+
+    req->current_call_id = NULL;
+
+    if (error) {
+        if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED)) {
+            _LOGD(agent, "delete secrets request cancelled: " LOG_REQ_FMT, LOG_REQ_ARG(req));
+            return;
+        }
+
+        _LOGD(agent,
+              "agent failed delete secrets request " LOG_REQ_FMT ": %s",
+              LOG_REQ_ARG(req),
+              error->message);
+    } else {
+        _LOGD(agent, "agent deleted secrets for request " LOG_REQ_FMT, LOG_REQ_ARG(req));
+    }
+
+    /* Tell the next agent to delete secrets */
+    request_next_agent(req);
+    if (error)
+        maybe_remove_agent_on_error(self, agent, error);
 }
 
 static void
-_con_del_request_start (Request *req)
+_con_del_request_start(Request *req)
 {
-	req->current_call_id = nm_secret_agent_delete_secrets (req->current,
-	                                                       req->con.path,
-	                                                       req->con.connection,
-	                                                       _con_del_request_done,
-	                                                       req);
-	if (!req->current_call_id) {
-		g_warn_if_reached ();
-		request_next_agent (req);
-	}
+    req->current_call_id = nm_secret_agent_delete_secrets(req->current,
+                                                          req->con.path,
+                                                          req->con.connection,
+                                                          _con_del_request_done,
+                                                          req);
+    if (!req->current_call_id) {
+        g_warn_if_reached();
+        request_next_agent(req);
+    }
 }
 
 void
-nm_agent_manager_delete_secrets (NMAgentManager *self,
-                                 const char *path,
-                                 NMConnection *connection)
+nm_agent_manager_delete_secrets(NMAgentManager *self, const char *path, NMConnection *connection)
 {
-	NMAuthSubject *subject;
-	Request *req;
-
-	g_return_if_fail (self != NULL);
-	g_return_if_fail (path && *path);
-	g_return_if_fail (NM_IS_CONNECTION (connection));
-
-	nm_log_dbg (LOGD_SETTINGS,
-	            "Deleting secrets for connection %s (%s)",
-	            path,
-	            nm_connection_get_id (connection));
-
-	subject = nm_auth_subject_new_internal ();
-	req = request_new (self,
-	                   REQUEST_TYPE_CON_DEL,
-	                   nm_connection_get_id (connection),
-	                   subject);
-	req->con.path = g_strdup (path);
-	req->con.connection = g_object_ref (connection);
-	g_object_unref (subject);
-
-	request_add_agents (self, req);
-	req->idle_id = g_idle_add (request_start, req);
+    NMAuthSubject *subject;
+    Request *      req;
+
+    g_return_if_fail(self != NULL);
+    g_return_if_fail(path && *path);
+    g_return_if_fail(NM_IS_CONNECTION(connection));
+
+    nm_log_dbg(LOGD_SETTINGS,
+               "Deleting secrets for connection %s (%s)",
+               path,
+               nm_connection_get_id(connection));
+
+    subject = nm_auth_subject_new_internal();
+    req     = request_new(self, REQUEST_TYPE_CON_DEL, nm_connection_get_id(connection), subject);
+    req->con.path       = g_strdup(path);
+    req->con.connection = g_object_ref(connection);
+    g_object_unref(subject);
+
+    request_add_agents(self, req);
+    req->idle_id = g_idle_add(request_start, req);
 }
 
 /*****************************************************************************/
 
 gboolean
-nm_agent_manager_has_agent_with_permission (NMAgentManager *self,
-                                            const char *username,
-                                            const char *permission)
+nm_agent_manager_has_agent_with_permission(NMAgentManager *self,
+                                           const char *    username,
+                                           const char *    permission)
 {
-	NMAgentManagerPrivate *priv;
-	NMSecretAgent *agent;
+    NMAgentManagerPrivate *priv;
+    NMSecretAgent *        agent;
 
-	g_return_val_if_fail (NM_IS_AGENT_MANAGER (self), FALSE);
-	g_return_val_if_fail (username, FALSE);
-	g_return_val_if_fail (permission, FALSE);
+    g_return_val_if_fail(NM_IS_AGENT_MANAGER(self), FALSE);
+    g_return_val_if_fail(username, FALSE);
+    g_return_val_if_fail(permission, FALSE);
 
-	priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
+    priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
 
-	c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
-		if (!agent->fully_registered)
-			continue;
-		if (!nm_streq0 (nm_secret_agent_get_owner_username (agent), username))
-			continue;
-		if (nm_secret_agent_has_permission (agent, permission))
-			return TRUE;
-	}
+    c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
+        if (!agent->fully_registered)
+            continue;
+        if (!nm_streq0(nm_secret_agent_get_owner_username(agent), username))
+            continue;
+        if (nm_secret_agent_has_permission(agent, permission))
+            return TRUE;
+    }
 
-	return FALSE;
+    return FALSE;
 }
 
 /*****************************************************************************/
 
 gboolean
-nm_agent_manager_all_agents_have_capability (NMAgentManager *manager,
-                                             NMAuthSubject *subject,
-                                             NMSecretAgentCapabilities capability)
+nm_agent_manager_all_agents_have_capability(NMAgentManager *          manager,
+                                            NMAuthSubject *           subject,
+                                            NMSecretAgentCapabilities capability)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (manager);
-	NMSecretAgent *agent;
-	gboolean subject_is_unix_process = (nm_auth_subject_get_subject_type (subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS);
-	gulong subject_uid = subject_is_unix_process ? nm_auth_subject_get_unix_process_uid (subject) : 0u;
-
-	c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
-		if (!agent->fully_registered)
-			continue;
-		if (   subject_is_unix_process
-		    && nm_secret_agent_get_owner_uid (agent) != subject_uid)
-			continue;
-		if (!(nm_secret_agent_get_capabilities (agent) & capability))
-			return FALSE;
-	}
-
-	return TRUE;
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(manager);
+    NMSecretAgent *        agent;
+    gboolean               subject_is_unix_process =
+        (nm_auth_subject_get_subject_type(subject) == NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS);
+    gulong subject_uid =
+        subject_is_unix_process ? nm_auth_subject_get_unix_process_uid(subject) : 0u;
+
+    c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst) {
+        if (!agent->fully_registered)
+            continue;
+        if (subject_is_unix_process && nm_secret_agent_get_owner_uid(agent) != subject_uid)
+            continue;
+        if (!(nm_secret_agent_get_capabilities(agent) & capability))
+            return FALSE;
+    }
+
+    return TRUE;
 }
 
 /*****************************************************************************/
 
 static void
-authority_changed_cb (NMAuthManager *auth_manager, NMAgentManager *self)
+authority_changed_cb(NMAuthManager *auth_manager, NMAgentManager *self)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	NMSecretAgent *agent;
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    NMSecretAgent *        agent;
 
-	c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst)
-		_agent_create_auth_chain (self, agent, NULL);
+    c_list_for_each_entry (agent, &priv->agent_lst_head, agent_lst)
+        _agent_create_auth_chain(self, agent, NULL);
 }
 
 /*****************************************************************************/
 
 static void
-nm_agent_manager_init (NMAgentManager *self)
+nm_agent_manager_init(NMAgentManager *self)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
 
-	priv->agent_version_id = 1;
-	c_list_init (&priv->agent_lst_head);
-	c_list_init (&priv->request_lst_head);
+    priv->agent_version_id = 1;
+    c_list_init(&priv->agent_lst_head);
+    c_list_init(&priv->request_lst_head);
 }
 
 static void
-constructed (GObject *object)
+constructed(GObject *object)
 {
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (object);
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(object);
 
-	G_OBJECT_CLASS (nm_agent_manager_parent_class)->constructed (object);
+    G_OBJECT_CLASS(nm_agent_manager_parent_class)->constructed(object);
 
-	priv->auth_mgr = g_object_ref (nm_auth_manager_get ());
-	priv->session_monitor = g_object_ref (nm_session_monitor_get ());
+    priv->auth_mgr        = g_object_ref(nm_auth_manager_get());
+    priv->session_monitor = g_object_ref(nm_session_monitor_get());
 
-	nm_dbus_object_export (NM_DBUS_OBJECT (object));
+    nm_dbus_object_export(NM_DBUS_OBJECT(object));
 
-	g_signal_connect (priv->auth_mgr,
-	                  NM_AUTH_MANAGER_SIGNAL_CHANGED,
-	                  G_CALLBACK (authority_changed_cb),
-	                  object);
+    g_signal_connect(priv->auth_mgr,
+                     NM_AUTH_MANAGER_SIGNAL_CHANGED,
+                     G_CALLBACK(authority_changed_cb),
+                     object);
 }
 
 static void
-dispose (GObject *object)
+dispose(GObject *object)
 {
-	NMAgentManager *self = NM_AGENT_MANAGER (object);
-	NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE (self);
-	Request *request;
-	NMSecretAgent *agent;
+    NMAgentManager *       self = NM_AGENT_MANAGER(object);
+    NMAgentManagerPrivate *priv = NM_AGENT_MANAGER_GET_PRIVATE(self);
+    Request *              request;
+    NMSecretAgent *        agent;
 
-	while ((request = c_list_first_entry (&priv->request_lst_head, Request, request_lst))) {
-		c_list_unlink (&request->request_lst);
-		req_complete_cancel (request, TRUE);
-	}
+    while ((request = c_list_first_entry(&priv->request_lst_head, Request, request_lst))) {
+        c_list_unlink(&request->request_lst);
+        req_complete_cancel(request, TRUE);
+    }
 
-	while ((agent = c_list_first_entry (&priv->agent_lst_head, NMSecretAgent, agent_lst)))
-		_agent_remove (self, agent);
+    while ((agent = c_list_first_entry(&priv->agent_lst_head, NMSecretAgent, agent_lst)))
+        _agent_remove(self, agent);
 
-	if (priv->auth_mgr) {
-		g_signal_handlers_disconnect_by_func (priv->auth_mgr,
-		                                      G_CALLBACK (authority_changed_cb),
-		                                      object);
-		g_clear_object (&priv->auth_mgr);
-	}
+    if (priv->auth_mgr) {
+        g_signal_handlers_disconnect_by_func(priv->auth_mgr,
+                                             G_CALLBACK(authority_changed_cb),
+                                             object);
+        g_clear_object(&priv->auth_mgr);
+    }
 
-	nm_dbus_object_unexport (NM_DBUS_OBJECT (object));
+    nm_dbus_object_unexport(NM_DBUS_OBJECT(object));
 
-	g_clear_object (&priv->session_monitor);
+    g_clear_object(&priv->session_monitor);
 
-	G_OBJECT_CLASS (nm_agent_manager_parent_class)->dispose (object);
+    G_OBJECT_CLASS(nm_agent_manager_parent_class)->dispose(object);
 }
 
 static const NMDBusInterfaceInfoExtended interface_info_agent_manager = {
-	.parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT (
-		NM_DBUS_INTERFACE_AGENT_MANAGER,
-		.methods = NM_DEFINE_GDBUS_METHOD_INFOS (
-			NM_DEFINE_DBUS_METHOD_INFO_EXTENDED (
-				NM_DEFINE_GDBUS_METHOD_INFO_INIT (
-					"Register",
-					.in_args = NM_DEFINE_GDBUS_ARG_INFOS (
-						NM_DEFINE_GDBUS_ARG_INFO ("identifier", "s"),
-					),
-				),
-				.handle = impl_agent_manager_register,
-			),
-			NM_DEFINE_DBUS_METHOD_INFO_EXTENDED (
-				NM_DEFINE_GDBUS_METHOD_INFO_INIT (
-					"RegisterWithCapabilities",
-					.in_args = NM_DEFINE_GDBUS_ARG_INFOS (
-						NM_DEFINE_GDBUS_ARG_INFO ("identifier",   "s"),
-						NM_DEFINE_GDBUS_ARG_INFO ("capabilities", "u"),
-					),
-				),
-				.handle = impl_agent_manager_register_with_capabilities,
-			),
-			NM_DEFINE_DBUS_METHOD_INFO_EXTENDED (
-				NM_DEFINE_GDBUS_METHOD_INFO_INIT (
-					"Unregister",
-				),
-				.handle = impl_agent_manager_unregister,
-			),
-		),
-	),
+    .parent = NM_DEFINE_GDBUS_INTERFACE_INFO_INIT(
+        NM_DBUS_INTERFACE_AGENT_MANAGER,
+        .methods = NM_DEFINE_GDBUS_METHOD_INFOS(
+            NM_DEFINE_DBUS_METHOD_INFO_EXTENDED(
+                NM_DEFINE_GDBUS_METHOD_INFO_INIT(
+                    "Register",
+                    .in_args =
+                        NM_DEFINE_GDBUS_ARG_INFOS(NM_DEFINE_GDBUS_ARG_INFO("identifier", "s"), ), ),
+                .handle = impl_agent_manager_register, ),
+            NM_DEFINE_DBUS_METHOD_INFO_EXTENDED(
+                NM_DEFINE_GDBUS_METHOD_INFO_INIT(
+                    "RegisterWithCapabilities",
+                    .in_args = NM_DEFINE_GDBUS_ARG_INFOS(
+                        NM_DEFINE_GDBUS_ARG_INFO("identifier", "s"),
+                        NM_DEFINE_GDBUS_ARG_INFO("capabilities", "u"), ), ),
+                .handle = impl_agent_manager_register_with_capabilities, ),
+            NM_DEFINE_DBUS_METHOD_INFO_EXTENDED(NM_DEFINE_GDBUS_METHOD_INFO_INIT("Unregister", ),
+                                                .handle = impl_agent_manager_unregister, ), ), ),
 };
 
 static void
-nm_agent_manager_class_init (NMAgentManagerClass *agent_manager_class)
+nm_agent_manager_class_init(NMAgentManagerClass *agent_manager_class)
 {
-	GObjectClass *object_class = G_OBJECT_CLASS (agent_manager_class);
-	NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS (agent_manager_class);
-
-	dbus_object_class->export_path = NM_DBUS_EXPORT_PATH_STATIC (NM_DBUS_PATH_AGENT_MANAGER);
-	dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS (&interface_info_agent_manager);
-
-	object_class->constructed = constructed;
-	object_class->dispose = dispose;
-
-	signals[AGENT_REGISTERED] =
-	    g_signal_new (NM_AGENT_MANAGER_AGENT_REGISTERED,
-	                  G_OBJECT_CLASS_TYPE (object_class),
-	                  G_SIGNAL_RUN_FIRST,
-	                  0,
-	                  NULL, NULL,
-	                  g_cclosure_marshal_VOID__OBJECT,
-	                  G_TYPE_NONE, 1,
-	                  G_TYPE_OBJECT);
+    GObjectClass *     object_class      = G_OBJECT_CLASS(agent_manager_class);
+    NMDBusObjectClass *dbus_object_class = NM_DBUS_OBJECT_CLASS(agent_manager_class);
+
+    dbus_object_class->export_path     = NM_DBUS_EXPORT_PATH_STATIC(NM_DBUS_PATH_AGENT_MANAGER);
+    dbus_object_class->interface_infos = NM_DBUS_INTERFACE_INFOS(&interface_info_agent_manager);
+
+    object_class->constructed = constructed;
+    object_class->dispose     = dispose;
+
+    signals[AGENT_REGISTERED] = g_signal_new(NM_AGENT_MANAGER_AGENT_REGISTERED,
+                                             G_OBJECT_CLASS_TYPE(object_class),
+                                             G_SIGNAL_RUN_FIRST,
+                                             0,
+                                             NULL,
+                                             NULL,
+                                             g_cclosure_marshal_VOID__OBJECT,
+                                             G_TYPE_NONE,
+                                             1,
+                                             G_TYPE_OBJECT);
 }