/* SPDX-License-Identifier: GPL-2.0-or-later */
/*
* Copyright (C) 2014 Red Hat, Inc.
*/
#include "nm-default.h"
#include "nm-auth-manager.h"
#include "c-list/src/c-list.h"
#include "nm-glib-aux/nm-dbus-aux.h"
#include "nm-errors.h"
#include "nm-core-internal.h"
#include "nm-dbus-manager.h"
#include "NetworkManagerUtils.h"
#define POLKIT_SERVICE "org.freedesktop.PolicyKit1"
#define POLKIT_OBJECT_PATH "/org/freedesktop/PolicyKit1/Authority"
#define POLKIT_INTERFACE "org.freedesktop.PolicyKit1.Authority"
#define CANCELLATION_ID_PREFIX "cancellation-id-"
#define CANCELLATION_TIMEOUT_MS 5000
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE_BASE(PROP_POLKIT_ENABLED, );
enum {
CHANGED_SIGNAL,
LAST_SIGNAL,
};
static guint signals[LAST_SIGNAL] = {0};
typedef struct {
CList calls_lst_head;
GDBusConnection *dbus_connection;
GCancellable * main_cancellable;
char * name_owner;
guint64 call_numid_counter;
guint changed_id;
guint name_owner_changed_id;
bool disposing : 1;
bool shutting_down : 1;
bool got_name_owner : 1;
NMAuthPolkitMode auth_polkit_mode : 3;
} NMAuthManagerPrivate;
struct _NMAuthManager {
GObject parent;
NMAuthManagerPrivate _priv;
};
struct _NMAuthManagerClass {
GObjectClass parent;
};
G_DEFINE_TYPE(NMAuthManager, nm_auth_manager, G_TYPE_OBJECT)
#define NM_AUTH_MANAGER_GET_PRIVATE(self) _NM_GET_PRIVATE(self, NMAuthManager, NM_IS_AUTH_MANAGER)
NM_DEFINE_SINGLETON_REGISTER(NMAuthManager);
/*****************************************************************************/
#define _NMLOG_PREFIX_NAME "auth"
#define _NMLOG_DOMAIN LOGD_CORE
#define _NMLOG(level, ...) \
G_STMT_START \
{ \
if (nm_logging_enabled((level), (_NMLOG_DOMAIN))) { \
char __prefix[30] = _NMLOG_PREFIX_NAME; \
\
if ((self) != singleton_instance) \
g_snprintf(__prefix, \
sizeof(__prefix), \
""_NMLOG_PREFIX_NAME \
"[%p]", \
(self)); \
_nm_log((level), \
(_NMLOG_DOMAIN), \
0, \
NULL, \
NULL, \
"%s: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
__prefix _NM_UTILS_MACRO_REST(__VA_ARGS__)); \
} \
} \
G_STMT_END
#define _NMLOG2(level, call_id, ...) \
G_STMT_START \
{ \
if (nm_logging_enabled((level), (_NMLOG_DOMAIN))) { \
NMAuthManagerCallId *_call_id = (call_id); \
char __prefix[30] = _NMLOG_PREFIX_NAME; \
\
if (_call_id->self != singleton_instance) \
g_snprintf(__prefix, \
sizeof(__prefix), \
""_NMLOG_PREFIX_NAME \
"[%p]", \
_call_id->self); \
_nm_log((level), \
(_NMLOG_DOMAIN), \
0, \
NULL, \
NULL, \
"%s: call[%" G_GUINT64_FORMAT "]: " _NM_UTILS_MACRO_FIRST(__VA_ARGS__), \
__prefix, \
_call_id->call_numid _NM_UTILS_MACRO_REST(__VA_ARGS__)); \
} \
} \
G_STMT_END
/*****************************************************************************/
gboolean
nm_auth_manager_get_polkit_enabled(NMAuthManager *self)
{
g_return_val_if_fail(NM_IS_AUTH_MANAGER(self), FALSE);
return NM_AUTH_MANAGER_GET_PRIVATE(self)->dbus_connection != NULL;
}
/*****************************************************************************/
static void
_emit_changed_signal(NMAuthManager *self)
{
g_signal_emit(self, signals[CHANGED_SIGNAL], 0);
}
typedef enum {
POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE = 0,
POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION = (1 << 0),
} PolkitCheckAuthorizationFlags;
struct _NMAuthManagerCallId {
CList calls_lst;
NMAuthManager * self;
GCancellable * dbus_cancellable;
NMAuthManagerCheckAuthorizationCallback callback;
gpointer user_data;
guint64 call_numid;
guint idle_id;
bool idle_is_authorized : 1;
};
#define cancellation_id_to_str_a(call_numid) \
nm_sprintf_bufa(NM_STRLEN(CANCELLATION_ID_PREFIX) + 60, \
CANCELLATION_ID_PREFIX "%" G_GUINT64_FORMAT, \
(call_numid))
static void
_call_id_free(NMAuthManagerCallId *call_id)
{
c_list_unlink(&call_id->calls_lst);
nm_clear_g_source(&call_id->idle_id);
if (call_id->dbus_cancellable) {
/* we have a pending D-Bus call. We keep the call-id instance alive
* for _call_check_authorize_cb() */
g_cancellable_cancel(call_id->dbus_cancellable);
return;
}
g_object_unref(call_id->self);
g_slice_free(NMAuthManagerCallId, call_id);
}
static void
_call_id_invoke_callback(NMAuthManagerCallId *call_id,
gboolean is_authorized,
gboolean is_challenge,
GError * error)
{
c_list_unlink(&call_id->calls_lst);
call_id
->callback(call_id->self, call_id, is_authorized, is_challenge, error, call_id->user_data);
_call_id_free(call_id);
}
static void
cancel_check_authorization_cb(GObject *source, GAsyncResult *res, gpointer user_data)
{
NMAuthManagerCallId *call_id = user_data;
gs_unref_variant GVariant *value = NULL;
gs_free_error GError *error = NULL;
value = g_dbus_connection_call_finish(G_DBUS_CONNECTION(source), res, &error);
if (g_error_matches(error, G_IO_ERROR, G_IO_ERROR_CANCELLED))
_LOG2T(call_id, "cancel request was cancelled");
else if (error)
_LOG2T(call_id, "cancel request failed: %s", error->message);
else
_LOG2T(call_id, "cancel request succeeded");
_call_id_free(call_id);
}
static void
_call_check_authorize_cb(GObject *proxy, GAsyncResult *res, gpointer user_data)
{
NMAuthManagerCallId * call_id = user_data;
NMAuthManager * self;
NMAuthManagerPrivate *priv;
gs_unref_variant GVariant *value = NULL;
gs_free_error GError *error = NULL;
gboolean is_authorized = FALSE;
gboolean is_challenge = FALSE;
/* we need to clear the cancelable, to signal for _call_id_free() that we
* are not in a pending call.
*
* Note how _call_id_free() kept call-id alive, even if the request was
* already cancelled. */
g_clear_object(&call_id->dbus_cancellable);
self = call_id->self;
priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
value = g_dbus_connection_call_finish(G_DBUS_CONNECTION(proxy), res, &error);
if (nm_utils_error_is_cancelled(error)) {
/* call_id was cancelled externally, but _call_id_free() kept call_id
* alive (and it has still the reference on @self. */
if (!priv->main_cancellable) {
/* we do a forced shutdown. There is no more time for cancelling... */
_call_id_free(call_id);
/* this shouldn't really happen, because:
* nm_auth_manager_check_authorization() only scheduled the D-Bus request at a time when
* main_cancellable was still set. It means, somebody called force-shutdown
* after call-id was schedule.
* force-shutdown should only be called after:
* - cancel all pending requests
* - give enough time to cancel the request and schedule a D-Bus call
* to CancelCheckAuthorization (below), before issuing force-shutdown. */
g_return_if_reached();
}
g_dbus_connection_call(priv->dbus_connection,
POLKIT_SERVICE,
POLKIT_OBJECT_PATH,
POLKIT_INTERFACE,
"CancelCheckAuthorization",
g_variant_new("(s)", cancellation_id_to_str_a(call_id->call_numid)),
G_VARIANT_TYPE("()"),
G_DBUS_CALL_FLAGS_NONE,
CANCELLATION_TIMEOUT_MS,
priv->main_cancellable,
cancel_check_authorization_cb,
call_id);
return;
}
if (!error) {
g_variant_get(value, "((bb@a{ss}))", &is_authorized, &is_challenge, NULL);
_LOG2T(call_id, "completed: authorized=%d, challenge=%d", is_authorized, is_challenge);
} else
_LOG2T(call_id, "completed: failed: %s", error->message);
_call_id_invoke_callback(call_id, is_authorized, is_challenge, error);
}
static gboolean
_call_on_idle(gpointer user_data)
{
NMAuthManagerCallId *call_id = user_data;
gboolean is_authorized;
gboolean is_challenge = FALSE;
is_authorized = call_id->idle_is_authorized;
call_id->idle_id = 0;
_LOG2T(call_id,
"completed: authorized=%d, challenge=%d (simulated)",
is_authorized,
is_challenge);
_call_id_invoke_callback(call_id, is_authorized, is_challenge, NULL);
return G_SOURCE_REMOVE;
}
/*
* @callback must never be invoked synchronously.
*
* @callback is always invoked exactly once, and never synchronously.
* You may cancel the invocation with nm_auth_manager_check_authorization_cancel(),
* but: you may only do so exactly once, and only before @callback is
* invoked. Even if you cancel the request, @callback will still be invoked
* (synchronously, during the _cancel() callback).
*
* The request keeps @self alive (it needs to do so, because when cancelling a
* request we might need to do an additional CancelCheckAuthorization call, for
* which @self must be live long enough).
*/
NMAuthManagerCallId *
nm_auth_manager_check_authorization(NMAuthManager * self,
NMAuthSubject * subject,
const char * action_id,
gboolean allow_user_interaction,
NMAuthManagerCheckAuthorizationCallback callback,
gpointer user_data)
{
NMAuthManagerPrivate * priv;
PolkitCheckAuthorizationFlags flags;
char subject_buf[64];
NMAuthManagerCallId * call_id;
g_return_val_if_fail(NM_IS_AUTH_MANAGER(self), NULL);
g_return_val_if_fail(NM_IN_SET(nm_auth_subject_get_subject_type(subject),
NM_AUTH_SUBJECT_TYPE_INTERNAL,
NM_AUTH_SUBJECT_TYPE_UNIX_PROCESS),
NULL);
g_return_val_if_fail(action_id, NULL);
priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
g_return_val_if_fail(!priv->disposing, NULL);
g_return_val_if_fail(!priv->shutting_down, NULL);
flags = allow_user_interaction ? POLKIT_CHECK_AUTHORIZATION_FLAGS_ALLOW_USER_INTERACTION
: POLKIT_CHECK_AUTHORIZATION_FLAGS_NONE;
call_id = g_slice_new(NMAuthManagerCallId);
*call_id = (NMAuthManagerCallId){
.self = g_object_ref(self),
.callback = callback,
.user_data = user_data,
.call_numid = ++priv->call_numid_counter,
.idle_is_authorized = TRUE,
};
c_list_link_tail(&priv->calls_lst_head, &call_id->calls_lst);
if (nm_auth_subject_get_subject_type(subject) == NM_AUTH_SUBJECT_TYPE_INTERNAL) {
_LOG2T(call_id,
"CheckAuthorization(%s), subject=%s (succeeding for internal request)",
action_id,
nm_auth_subject_to_string(subject, subject_buf, sizeof(subject_buf)));
call_id->idle_id = g_idle_add(_call_on_idle, call_id);
} else if (nm_auth_subject_get_unix_process_uid(subject) == 0) {
_LOG2T(call_id,
"CheckAuthorization(%s), subject=%s (succeeding for root)",
action_id,
nm_auth_subject_to_string(subject, subject_buf, sizeof(subject_buf)));
call_id->idle_id = g_idle_add(_call_on_idle, call_id);
} else if (priv->auth_polkit_mode != NM_AUTH_POLKIT_MODE_USE_POLKIT) {
_LOG2T(call_id,
"CheckAuthorization(%s), subject=%s (PolicyKit disabled and always %s authorization "
"to non-root user)",
action_id,
nm_auth_subject_to_string(subject, subject_buf, sizeof(subject_buf)),
priv->auth_polkit_mode == NM_AUTH_POLKIT_MODE_ALLOW_ALL ? "grant" : "deny");
call_id->idle_is_authorized = (priv->auth_polkit_mode == NM_AUTH_POLKIT_MODE_ALLOW_ALL);
call_id->idle_id = g_idle_add(_call_on_idle, call_id);
} else {
GVariant * parameters;
GVariantBuilder builder;
GVariant * subject_value;
GVariant * details_value;
subject_value = nm_auth_subject_unix_to_polkit_gvariant(subject);
nm_assert(g_variant_is_floating(subject_value));
/* ((PolkitDetails *)NULL) */
g_variant_builder_init(&builder, G_VARIANT_TYPE("a{ss}"));
details_value = g_variant_builder_end(&builder);
parameters = g_variant_new("(@(sa{sv})s@a{ss}us)",
subject_value,
action_id,
details_value,
(guint32) flags,
cancellation_id_to_str_a(call_id->call_numid));
_LOG2T(call_id,
"CheckAuthorization(%s), subject=%s",
action_id,
nm_auth_subject_to_string(subject, subject_buf, sizeof(subject_buf)));
call_id->dbus_cancellable = g_cancellable_new();
nm_assert(priv->main_cancellable);
g_dbus_connection_call(priv->dbus_connection,
POLKIT_SERVICE,
POLKIT_OBJECT_PATH,
POLKIT_INTERFACE,
"CheckAuthorization",
parameters,
G_VARIANT_TYPE("((bba{ss}))"),
G_DBUS_CALL_FLAGS_NONE,
G_MAXINT, /* no timeout */
call_id->dbus_cancellable,
_call_check_authorize_cb,
call_id);
}
return call_id;
}
void
nm_auth_manager_check_authorization_cancel(NMAuthManagerCallId *call_id)
{
NMAuthManager *self;
gs_free_error GError *error = NULL;
g_return_if_fail(call_id);
self = call_id->self;
g_return_if_fail(NM_IS_AUTH_MANAGER(self));
g_return_if_fail(!c_list_is_empty(&call_id->calls_lst));
nm_assert(
c_list_contains(&NM_AUTH_MANAGER_GET_PRIVATE(self)->calls_lst_head, &call_id->calls_lst));
nm_utils_error_set_cancelled(&error, FALSE, "NMAuthManager");
_LOG2T(call_id, "completed: failed due to call cancelled");
_call_id_invoke_callback(call_id, FALSE, FALSE, error);
}
/*****************************************************************************/
static void
changed_signal_cb(GDBusConnection *connection,
const char * sender_name,
const char * object_path,
const char * interface_name,
const char * signal_name,
GVariant * parameters,
gpointer user_data)
{
NMAuthManager * self = user_data;
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
gboolean valid_sender;
nm_assert(nm_streq0(signal_name, "Changed"));
valid_sender = nm_streq0(priv->name_owner, sender_name);
_LOGD("dbus-signal: \"Changed\" notification%s", valid_sender ? "" : " (ignore)");
if (valid_sender)
_emit_changed_signal(self);
}
static void
_name_owner_changed(NMAuthManager *self, const char *name_owner, gboolean is_initial)
{
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
gboolean is_changed;
gs_free char * old_name_owner = NULL;
if (is_initial)
priv->got_name_owner = TRUE;
else {
if (!priv->got_name_owner)
return;
}
name_owner = nm_str_not_empty(name_owner);
is_changed = !nm_streq0(priv->name_owner, name_owner);
if (is_changed) {
old_name_owner = g_steal_pointer(&priv->name_owner);
priv->name_owner = g_strdup(name_owner);
} else {
if (!is_initial)
return;
}
if (!priv->name_owner) {
if (is_initial)
_LOGT("name-owner: polkit not running");
else
_LOGT("name-owner: polkit stopped (was %s)", old_name_owner);
} else {
if (is_initial)
_LOGT("name-owner: polkit is running (now %s)", priv->name_owner);
else if (old_name_owner)
_LOGT("name-owner: polkit restarted (now %s, was %s)",
priv->name_owner,
old_name_owner);
else
_LOGT("name-owner: polkit started (now %s)", priv->name_owner);
}
if (priv->name_owner)
_emit_changed_signal(self);
}
static void
_name_owner_changed_cb(GDBusConnection *connection,
const char * sender_name,
const char * object_path,
const char * interface_name,
const char * signal_name,
GVariant * parameters,
gpointer user_data)
{
NMAuthManager *self = user_data;
const char * new_owner;
if (!g_variant_is_of_type(parameters, G_VARIANT_TYPE("(sss)")))
return;
g_variant_get(parameters, "(&s&s&s)", NULL, NULL, &new_owner);
_name_owner_changed(self, new_owner, FALSE);
}
static void
_name_owner_get_cb(const char *name_owner, GError *error, gpointer user_data)
{
if (!nm_utils_error_is_cancelled(error))
_name_owner_changed(user_data, name_owner, TRUE);
}
/*****************************************************************************/
NMAuthManager *
nm_auth_manager_get()
{
g_return_val_if_fail(singleton_instance, NULL);
return singleton_instance;
}
void
nm_auth_manager_force_shutdown(NMAuthManager *self)
{
NMAuthManagerPrivate *priv;
g_return_if_fail(NM_IS_AUTH_MANAGER(self));
priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
/* FIXME(shutdown): ensure we properly call this API during shutdown as
* described next. */
/* while we have pending requests (NMAuthManagerCallId), the instance
* is kept alive.
*
* Even if the caller cancels all pending call-ids, we still need to keep
* a reference to self, in order to handle pending CancelCheckAuthorization
* requests.
*
* To do a coordinated shutdown, do the following:
* - cancel all pending NMAuthManagerCallId requests.
* - ensure everybody unrefs the NMAuthManager instance. If by that, the instance
* gets destroyed, the shutdown already completed successfully.
* - Otherwise, the object is kept alive by pending CancelCheckAuthorization requests.
* wait a certain timeout (1 second) for all requests to complete (by watching
* for destruction of NMAuthManager).
* - if that doesn't happen within timeout, issue nm_auth_manager_force_shutdown() and
* wait longer. After that, soon the instance should be destroyed and you
* did a successful shutdown.
* - if the instance was still not destroyed within a short timeout, you leaked
* resources. You cannot properly shutdown.
*/
priv->shutting_down = TRUE;
nm_clear_g_cancellable(&priv->main_cancellable);
}
/*****************************************************************************/
static void
set_property(GObject *object, guint prop_id, const GValue *value, GParamSpec *pspec)
{
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE(object);
int v_int;
switch (prop_id) {
case PROP_POLKIT_ENABLED:
/* construct-only */
v_int = g_value_get_int(value);
g_return_if_fail(NM_IN_SET(v_int,
NM_AUTH_POLKIT_MODE_ROOT_ONLY,
NM_AUTH_POLKIT_MODE_ALLOW_ALL,
NM_AUTH_POLKIT_MODE_USE_POLKIT));
priv->auth_polkit_mode = v_int;
nm_assert(priv->auth_polkit_mode == v_int);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
/*****************************************************************************/
static void
nm_auth_manager_init(NMAuthManager *self)
{
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
c_list_init(&priv->calls_lst_head);
priv->auth_polkit_mode = NM_AUTH_POLKIT_MODE_ROOT_ONLY;
}
static void
constructed(GObject *object)
{
NMAuthManager * self = NM_AUTH_MANAGER(object);
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
NMLogLevel logl = LOGL_DEBUG;
const char * create_message;
G_OBJECT_CLASS(nm_auth_manager_parent_class)->constructed(object);
if (priv->auth_polkit_mode != NM_AUTH_POLKIT_MODE_USE_POLKIT) {
if (priv->auth_polkit_mode == NM_AUTH_POLKIT_MODE_ROOT_ONLY)
create_message = "polkit disabled, root-only";
else
create_message = "polkit disabled, allow-all";
goto out;
}
priv->dbus_connection = nm_g_object_ref(NM_MAIN_DBUS_CONNECTION_GET);
if (!priv->dbus_connection) {
/* This warrants an info level message. */
logl = LOGL_INFO;
create_message =
"D-Bus connection not available. Polkit is disabled and only root will be authorized.";
priv->auth_polkit_mode = NM_AUTH_POLKIT_MODE_ROOT_ONLY;
goto out;
}
priv->main_cancellable = g_cancellable_new();
priv->name_owner_changed_id =
nm_dbus_connection_signal_subscribe_name_owner_changed(priv->dbus_connection,
POLKIT_SERVICE,
_name_owner_changed_cb,
self,
NULL);
priv->changed_id = g_dbus_connection_signal_subscribe(priv->dbus_connection,
POLKIT_SERVICE,
POLKIT_INTERFACE,
"Changed",
POLKIT_OBJECT_PATH,
NULL,
G_DBUS_SIGNAL_FLAGS_NONE,
changed_signal_cb,
self,
NULL);
nm_dbus_connection_call_get_name_owner(priv->dbus_connection,
POLKIT_SERVICE,
-1,
priv->main_cancellable,
_name_owner_get_cb,
self);
create_message = "polkit enabled";
out:
_NMLOG(logl, "create auth-manager: %s", create_message);
}
NMAuthManager *
nm_auth_manager_setup(NMAuthPolkitMode auth_polkit_mode)
{
NMAuthManager *self;
g_return_val_if_fail(!singleton_instance, singleton_instance);
nm_assert(NM_IN_SET(auth_polkit_mode,
NM_AUTH_POLKIT_MODE_ROOT_ONLY,
NM_AUTH_POLKIT_MODE_ALLOW_ALL,
NM_AUTH_POLKIT_MODE_USE_POLKIT));
self = g_object_new(NM_TYPE_AUTH_MANAGER,
NM_AUTH_MANAGER_POLKIT_ENABLED,
(int) auth_polkit_mode,
NULL);
_LOGD("set instance");
singleton_instance = self;
nm_singleton_instance_register();
nm_log_dbg(LOGD_CORE,
"setup %s singleton (" NM_HASH_OBFUSCATE_PTR_FMT ")",
"NMAuthManager",
NM_HASH_OBFUSCATE_PTR(singleton_instance));
return self;
}
static void
dispose(GObject *object)
{
NMAuthManager * self = NM_AUTH_MANAGER(object);
NMAuthManagerPrivate *priv = NM_AUTH_MANAGER_GET_PRIVATE(self);
_LOGD("dispose");
nm_assert(c_list_is_empty(&priv->calls_lst_head));
priv->disposing = TRUE;
nm_clear_g_cancellable(&priv->main_cancellable);
nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->name_owner_changed_id);
nm_clear_g_dbus_connection_signal(priv->dbus_connection, &priv->changed_id);
G_OBJECT_CLASS(nm_auth_manager_parent_class)->dispose(object);
g_clear_object(&priv->dbus_connection);
nm_clear_g_free(&priv->name_owner);
}
static void
nm_auth_manager_class_init(NMAuthManagerClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
object_class->set_property = set_property;
object_class->constructed = constructed;
object_class->dispose = dispose;
obj_properties[PROP_POLKIT_ENABLED] =
g_param_spec_int(NM_AUTH_MANAGER_POLKIT_ENABLED,
"",
"",
NM_AUTH_POLKIT_MODE_ROOT_ONLY,
NM_AUTH_POLKIT_MODE_USE_POLKIT,
NM_AUTH_POLKIT_MODE_USE_POLKIT,
G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS);
g_object_class_install_properties(object_class, _PROPERTY_ENUMS_LAST, obj_properties);
signals[CHANGED_SIGNAL] = g_signal_new(NM_AUTH_MANAGER_SIGNAL_CHANGED,
NM_TYPE_AUTH_MANAGER,
G_SIGNAL_RUN_LAST,
0,
NULL,
NULL,
g_cclosure_marshal_VOID__VOID,
G_TYPE_NONE,
0);
}