diff options
Diffstat (limited to 'src/nm-active-connection.c')
| -rw-r--r-- | src/nm-active-connection.c | 439 |
1 files changed, 260 insertions, 179 deletions
diff --git a/src/nm-active-connection.c b/src/nm-active-connection.c index 3a8e6cf5..ad6b08b3 100644 --- a/src/nm-active-connection.c +++ b/src/nm-active-connection.c @@ -20,33 +20,29 @@ #include "config.h" -#include <glib.h> - -#include "nm-types.h" +#include "nm-default.h" #include "nm-active-connection.h" #include "nm-dbus-interface.h" -#include "nm-logging.h" -#include "nm-dbus-glib-types.h" -#include "nm-dbus-manager.h" #include "nm-device.h" #include "nm-settings-connection.h" +#include "nm-simple-connection.h" #include "nm-auth-utils.h" #include "nm-auth-subject.h" #include "NetworkManagerUtils.h" -#include "gsystem-local-alloc.h" -#include "nm-active-connection-glue.h" -#include "nm-glib-compat.h" +#include "nm-core-internal.h" + +#include "nmdbus-active-connection.h" /* Base class for anything implementing the Connection.Active D-Bus interface */ -G_DEFINE_ABSTRACT_TYPE (NMActiveConnection, nm_active_connection, G_TYPE_OBJECT) +G_DEFINE_ABSTRACT_TYPE (NMActiveConnection, nm_active_connection, NM_TYPE_EXPORTED_OBJECT) #define NM_ACTIVE_CONNECTION_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), \ NM_TYPE_ACTIVE_CONNECTION, \ NMActiveConnectionPrivate)) typedef struct { - NMConnection *connection; - char *path; + NMSettingsConnection *settings_connection; + NMConnection *applied_connection; char *specific_object; NMDevice *device; @@ -89,7 +85,7 @@ enum { PROP_VPN, PROP_MASTER, - PROP_INT_CONNECTION, + PROP_INT_SETTINGS_CONNECTION, PROP_INT_DEVICE, PROP_INT_SUBJECT, PROP_INT_MASTER, @@ -114,42 +110,27 @@ static void _device_cleanup (NMActiveConnection *self); #define _NMLOG_PREFIX_NAME "active-connection" #define _NMLOG(level, ...) \ G_STMT_START { \ - const NMLogLevel __level = (level); \ + char _sbuf[64]; \ \ - if (nm_logging_enabled (__level, _NMLOG_DOMAIN)) { \ - char __prefix[128]; \ - const char *__p_prefix = _NMLOG_PREFIX_NAME; \ - const void *const __self = (self); \ - \ - if (__self) { \ - g_snprintf (__prefix, sizeof (__prefix), "%s[%p]", _NMLOG_PREFIX_NAME, __self); \ - __p_prefix = __prefix; \ - } \ - _nm_log (__level, _NMLOG_DOMAIN, 0, \ - "%s: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__), \ - __p_prefix _NM_UTILS_MACRO_REST (__VA_ARGS__)); \ - } \ + nm_log ((level), _NMLOG_DOMAIN, \ + "%s%s: " _NM_UTILS_MACRO_FIRST (__VA_ARGS__), \ + _NMLOG_PREFIX_NAME, \ + self ? nm_sprintf_buf (_sbuf, "[%p]", self) : "" \ + _NM_UTILS_MACRO_REST (__VA_ARGS__)); \ } G_STMT_END /****************************************************************/ -static const char * -state_to_string (NMActiveConnectionState state) -{ - switch (state) { - case NM_ACTIVE_CONNECTION_STATE_UNKNOWN: - return "unknown"; - case NM_ACTIVE_CONNECTION_STATE_ACTIVATING: - return "activating"; - case NM_ACTIVE_CONNECTION_STATE_ACTIVATED: - return "activated"; - case NM_ACTIVE_CONNECTION_STATE_DEACTIVATING: - return "deactivating"; - case NM_ACTIVE_CONNECTION_STATE_DEACTIVATED: - return "deactivated"; - } - return "(none)"; -} +NM_UTILS_STRING_LOOKUP_TABLE_DEFINE_STATIC (_state_to_string, NMActiveConnectionState, NULL, + [NM_ACTIVE_CONNECTION_STATE_UNKNOWN] = "unknown", + [NM_ACTIVE_CONNECTION_STATE_ACTIVATING] = "activating", + [NM_ACTIVE_CONNECTION_STATE_ACTIVATED] = "activated", + [NM_ACTIVE_CONNECTION_STATE_DEACTIVATING] = "deactivating", + [NM_ACTIVE_CONNECTION_STATE_DEACTIVATED] = "deactivated", +); +#define state_to_string(state) NM_UTILS_STRING_LOOKUP_TABLE (_state_to_string, state) + +/****************************************************************/ NMActiveConnectionState nm_active_connection_get_state (NMActiveConnection *self) @@ -171,6 +152,10 @@ nm_active_connection_set_state (NMActiveConnection *self, if (priv->state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) g_return_if_fail (new_state != NM_ACTIVE_CONNECTION_STATE_DEACTIVATED); + _LOGD ("set state %s (was %s)", + state_to_string (new_state), + state_to_string (priv->state)); + old_state = priv->state; priv->state = new_state; priv->state_set = TRUE; @@ -180,7 +165,7 @@ nm_active_connection_set_state (NMActiveConnection *self, if ( new_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATED || old_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) { - nm_settings_connection_update_timestamp (NM_SETTINGS_CONNECTION (priv->connection), + nm_settings_connection_update_timestamp (priv->settings_connection, (guint64) time (NULL), TRUE); } @@ -213,59 +198,120 @@ nm_active_connection_set_state (NMActiveConnection *self, } const char * -nm_active_connection_get_id (NMActiveConnection *self) +nm_active_connection_get_settings_connection_id (NMActiveConnection *self) { + NMSettingsConnection *con; + g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (self), NULL); - return nm_connection_get_id (NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->connection); + con = NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->settings_connection; + return con + ? nm_connection_get_id (NM_CONNECTION (con)) + : NULL; } -const char * -nm_active_connection_get_uuid (NMActiveConnection *self) +NMSettingsConnection * +_nm_active_connection_get_settings_connection (NMActiveConnection *self) { g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (self), NULL); - return nm_connection_get_uuid (NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->connection); + return NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->settings_connection; } -NMConnection * -nm_active_connection_get_connection (NMActiveConnection *self) +NMSettingsConnection * +nm_active_connection_get_settings_connection (NMActiveConnection *self) { - return NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->connection; + NMSettingsConnection *con; + + con = _nm_active_connection_get_settings_connection (self); + + /* Only call this function on an active-connection that is already + * fully set-up (i.e. that has a settings-connection). Other uses + * indicate a bug. */ + g_return_val_if_fail (con, NULL); + return con; } -const char * -nm_active_connection_get_connection_type (NMActiveConnection *self) +NMConnection * +nm_active_connection_get_applied_connection (NMActiveConnection *self) { - NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); + NMConnection *con; + + g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (self), NULL); - if (priv->connection == NULL) - return NULL; + con = NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->applied_connection; - return nm_connection_get_connection_type (priv->connection); + /* Only call this function on an active-connection that is already + * fully set-up (i.e. that has a settings-connection). Other uses + * indicate a bug. */ + g_return_val_if_fail (con, NULL); + return con; } void -nm_active_connection_set_connection (NMActiveConnection *self, - NMConnection *connection) +nm_active_connection_set_settings_connection (NMActiveConnection *self, + NMSettingsConnection *connection) { - NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); + NMActiveConnectionPrivate *priv; + + g_return_if_fail (NM_IS_ACTIVE_CONNECTION (self)); - /* Can't change connection after the ActiveConnection is exported over D-Bus */ - g_return_if_fail (priv->path == NULL); - g_return_if_fail (priv->connection == NULL || !NM_IS_SETTINGS_CONNECTION (priv->connection)); + priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); - if (priv->connection) - g_object_unref (priv->connection); - priv->connection = g_object_ref (connection); + g_return_if_fail (NM_IS_SETTINGS_CONNECTION (connection)); + g_return_if_fail (!priv->settings_connection); + g_return_if_fail (!priv->applied_connection); + + /* Can't change connection after the ActiveConnection is exported over D-Bus. + * + * Later, we want to change the settings-connection of an activated connection. + * When doing that, this changes the assumption that the settings-connection + * never changes (once it's set). That has effects for NMVpnConnection and + * NMActivationRequest. + * For example, we'd have to cancel all pending seret requests. */ + g_return_if_fail (!nm_exported_object_is_exported (NM_EXPORTED_OBJECT (self))); + + priv->settings_connection = g_object_ref (connection); + priv->applied_connection = nm_simple_connection_new_clone (NM_CONNECTION (priv->settings_connection)); + nm_connection_clear_secrets (priv->applied_connection); } -const char * -nm_active_connection_get_path (NMActiveConnection *self) +gboolean +nm_active_connection_has_unmodified_applied_connection (NMActiveConnection *self, NMSettingCompareFlags compare_flags) +{ + NMActiveConnectionPrivate *priv; + + g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (self), FALSE); + + priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); + + g_return_val_if_fail (priv->settings_connection, FALSE); + + return nm_settings_connection_has_unmodified_applied_connection (priv->settings_connection, + priv->applied_connection, + compare_flags); +} + +/*******************************************************************/ + +void +nm_active_connection_clear_secrets (NMActiveConnection *self) { - return NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->path; + NMActiveConnectionPrivate *priv; + + g_return_if_fail (NM_IS_ACTIVE_CONNECTION (self)); + + priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); + + if (nm_settings_connection_has_unmodified_applied_connection (priv->settings_connection, + priv->applied_connection, + NM_SETTING_COMPARE_FLAG_NONE)) + nm_connection_clear_secrets ((NMConnection *) priv->settings_connection); + nm_connection_clear_secrets (priv->applied_connection); } +/*******************************************************************/ + const char * nm_active_connection_get_specific_object (NMActiveConnection *self) { @@ -341,18 +387,6 @@ nm_active_connection_get_default6 (NMActiveConnection *self) return NM_ACTIVE_CONNECTION_GET_PRIVATE (self)->is_default6; } -void -nm_active_connection_export (NMActiveConnection *self) -{ - NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); - static guint32 counter = 0; - - g_assert (priv->device || priv->vpn); - - priv->path = g_strdup_printf (NM_DBUS_PATH "/ActiveConnection/%d", counter++); - nm_dbus_manager_register_object (nm_dbus_manager_get (), priv->path, self); -} - NMAuthSubject * nm_active_connection_get_subject (NMActiveConnection *self) { @@ -450,6 +484,14 @@ nm_active_connection_set_device (NMActiveConnection *self, NMDevice *device) if (device == priv->device) return TRUE; + _LOGD ("set device %s%s%s [%p]", + NM_PRINT_FMT_QUOTED (device && nm_device_get_iface (device), + "\"", + nm_device_get_iface (device), + "\"", + device ? "(unknown)" : "(null)"), + device); + old_device = priv->device ? g_object_ref (priv->device) : NULL; _device_cleanup (self); @@ -459,7 +501,7 @@ nm_active_connection_set_device (NMActiveConnection *self, NMDevice *device) priv->device = g_object_ref (device); - g_signal_connect (device, "state-changed", + g_signal_connect (device, NM_DEVICE_STATE_CHANGED, G_CALLBACK (device_state_changed), self); g_signal_connect (device, "notify::master", G_CALLBACK (device_master_changed), self); @@ -470,8 +512,13 @@ nm_active_connection_set_device (NMActiveConnection *self, NMDevice *device) priv->pending_activation_id = g_strdup_printf ("activation::%p", (void *)self); nm_device_add_pending_action (device, priv->pending_activation_id, TRUE); } - } else + } else { + /* The ActiveConnection's device can only be cleared after the + * connection is activated. + */ + g_warn_if_fail (priv->state > NM_ACTIVE_CONNECTION_STATE_UNKNOWN); priv->device = NULL; + } g_object_notify (G_OBJECT (self), NM_ACTIVE_CONNECTION_INT_DEVICE); g_signal_emit (self, signals[DEVICE_CHANGED], 0, priv->device, old_device); @@ -508,34 +555,34 @@ static void check_master_ready (NMActiveConnection *self) { NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); - NMActiveConnectionState master_state = NM_ACTIVE_CONNECTION_STATE_UNKNOWN; - - if (priv->state != NM_ACTIVE_CONNECTION_STATE_ACTIVATING) { - _LOGD ("not signalling master-ready (not activating)"); - return; - } - if (!priv->master) { - _LOGD ("not signalling master-ready (no master)"); - return; - } - if (priv->master_ready) { - _LOGD ("not signalling master-ready (already signaled)"); - return; - } + gboolean signalling = FALSE; /* ActiveConnetions don't enter the ACTIVATING state until they have a * NMDevice in PREPARE or higher states, so the master active connection's * device will be ready to accept slaves when the master is in ACTIVATING * or higher states. */ - master_state = nm_active_connection_get_state (priv->master); - _LOGD ("master ActiveConnection [%p] state now '%s' (%d)", - priv->master, state_to_string (master_state), master_state); - - if ( master_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATING - || master_state == NM_ACTIVE_CONNECTION_STATE_ACTIVATED) { - _LOGD ("signalling master-ready"); + if ( !priv->master_ready + && priv->master + && priv->state == NM_ACTIVE_CONNECTION_STATE_ACTIVATING + && NM_IN_SET (nm_active_connection_get_state (priv->master), + NM_ACTIVE_CONNECTION_STATE_ACTIVATING, + NM_ACTIVE_CONNECTION_STATE_ACTIVATED)) { + signalling = TRUE; + } + _LOGD ("check-master-ready: %s (state %s, %s)", + signalling + ? "signal" + : (priv->master_ready ? "already signalled" : "not signalling"), + state_to_string (priv->state), + priv->master + ? nm_sprintf_bufa (128, "master %p is in state %s", + priv->master, + state_to_string (nm_active_connection_get_state (priv->master))) + : "no master"); + + if (signalling) { priv->master_ready = TRUE; g_object_notify (G_OBJECT (self), NM_ACTIVE_CONNECTION_INT_MASTER_READY); @@ -553,17 +600,14 @@ master_state_cb (NMActiveConnection *master, gpointer user_data) { NMActiveConnection *self = NM_ACTIVE_CONNECTION (user_data); - NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); NMActiveConnectionState master_state = nm_active_connection_get_state (master); + NMDevice *master_device = nm_active_connection_get_device (master); check_master_ready (self); - _LOGD ("master ActiveConnection [%p] state now '%s' (%d)", - master, state_to_string (master_state), master_state); - - if ( master_state >= NM_ACTIVE_CONNECTION_STATE_DEACTIVATING - && !priv->master_ready) { - /* Master failed without ever creating its device */ + if ( master_state == NM_ACTIVE_CONNECTION_STATE_DEACTIVATING + && (!master_device || !nm_device_is_real (master_device))) { + /* Master failed without ever creating or realizing its device */ if (NM_ACTIVE_CONNECTION_GET_CLASS (self)->master_failed) NM_ACTIVE_CONNECTION_GET_CLASS (self)->master_failed (self); } @@ -590,14 +634,16 @@ nm_active_connection_set_master (NMActiveConnection *self, NMActiveConnection *m /* Master is write-once, and must be set before exporting the object */ g_return_if_fail (priv->master == NULL); - g_return_if_fail (priv->path == NULL); + g_return_if_fail (!nm_exported_object_is_exported (NM_EXPORTED_OBJECT (self))); if (priv->device) { /* Note, the master ActiveConnection may not yet have a device */ g_return_if_fail (priv->device != nm_active_connection_get_device (master)); } - _LOGD ("master ActiveConnection is [%p] %s", - master, nm_active_connection_get_id (master)); + _LOGD ("set master %p, %s, state %s", + master, + nm_active_connection_get_settings_connection_id (master), + state_to_string (nm_active_connection_get_state (master))); priv->master = g_object_ref (master); g_signal_connect (priv->master, @@ -633,7 +679,7 @@ nm_active_connection_get_assumed (NMActiveConnection *self) static void auth_done (NMAuthChain *chain, GError *error, - DBusGMethodInvocation *unused, + GDBusMethodInvocation *unused, gpointer user_data) { NMActiveConnection *self = NM_ACTIVE_CONNECTION (user_data); @@ -692,6 +738,9 @@ done: /** * nm_active_connection_authorize: * @self: the #NMActiveConnection + * @initial_connection: (allow-none): for add-and-activate, there + * is no @settings_connection available when creating the active connection. + * Instead pass an alternative connection. * @result_func: function to be called on success or error * @user_data1: pointer passed to @result_func * @user_data2: additional pointer passed to @result_func @@ -702,16 +751,29 @@ done: */ void nm_active_connection_authorize (NMActiveConnection *self, + NMConnection *initial_connection, NMActiveConnectionAuthResultFunc result_func, gpointer user_data1, gpointer user_data2) { NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); const char *wifi_permission = NULL; + NMConnection *con; g_return_if_fail (result_func != NULL); g_return_if_fail (priv->chain == NULL); + if (initial_connection) { + g_return_if_fail (NM_IS_CONNECTION (initial_connection)); + g_return_if_fail (!priv->settings_connection); + g_return_if_fail (!priv->applied_connection); + con = initial_connection; + } else { + g_return_if_fail (NM_IS_SETTINGS_CONNECTION (priv->settings_connection)); + g_return_if_fail (NM_IS_CONNECTION (priv->applied_connection)); + con = priv->applied_connection; + } + priv->chain = nm_auth_chain_new_subject (priv->subject, NULL, auth_done, self); g_assert (priv->chain); @@ -719,7 +781,7 @@ nm_active_connection_authorize (NMActiveConnection *self, nm_auth_chain_add_call (priv->chain, NM_AUTH_PERMISSION_NETWORK_CONTROL, TRUE); /* Shared wifi connections require special permissions too */ - wifi_permission = nm_utils_get_shared_wifi_permission (priv->connection); + wifi_permission = nm_utils_get_shared_wifi_permission (con); if (wifi_permission) { priv->wifi_shared_permission = wifi_permission; nm_auth_chain_add_call (priv->chain, wifi_permission, TRUE); @@ -736,28 +798,42 @@ nm_active_connection_authorize (NMActiveConnection *self, static void nm_active_connection_init (NMActiveConnection *self) { + _LOGT ("creating"); } static void constructed (GObject *object) { + NMActiveConnection *self = (NMActiveConnection *) object; + NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); + G_OBJECT_CLASS (nm_active_connection_parent_class)->constructed (object); - g_assert (NM_ACTIVE_CONNECTION_GET_PRIVATE (object)->subject); + + _LOGD ("constructed (%s)", G_OBJECT_TYPE_NAME (self)); + + g_return_if_fail (priv->subject); } static void set_property (GObject *object, guint prop_id, - const GValue *value, GParamSpec *pspec) + const GValue *value, GParamSpec *pspec) { NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (object); const char *tmp; + NMSettingsConnection *con; switch (prop_id) { - case PROP_INT_CONNECTION: - g_warn_if_fail (priv->connection == NULL); - priv->connection = g_value_dup_object (value); + case PROP_INT_SETTINGS_CONNECTION: + /* construct-only */ + con = g_value_get_object (value); + if (con) { + priv->settings_connection = g_object_ref (con); + priv->applied_connection = nm_simple_connection_new_clone (NM_CONNECTION (con)); + nm_connection_clear_secrets (priv->applied_connection); + } break; case PROP_INT_DEVICE: + /* construct-only */ nm_active_connection_set_device (NM_ACTIVE_CONNECTION (object), g_value_get_object (value)); break; case PROP_INT_SUBJECT: @@ -767,10 +843,10 @@ set_property (GObject *object, guint prop_id, nm_active_connection_set_master (NM_ACTIVE_CONNECTION (object), g_value_get_object (value)); break; case PROP_SPECIFIC_OBJECT: - tmp = g_value_get_boxed (value); + tmp = g_value_get_string (value); /* NM uses "/" to mean NULL */ if (g_strcmp0 (tmp, "/") != 0) - priv->specific_object = g_value_dup_boxed (value); + priv->specific_object = g_strdup (tmp); break; case PROP_DEFAULT: priv->is_default = !!g_value_get_boolean (value); @@ -791,7 +867,7 @@ set_property (GObject *object, guint prop_id, static void get_property (GObject *object, guint prop_id, - GValue *value, GParamSpec *pspec) + GValue *value, GParamSpec *pspec) { NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (object); GPtrArray *devices; @@ -799,25 +875,26 @@ get_property (GObject *object, guint prop_id, switch (prop_id) { case PROP_CONNECTION: - g_value_set_boxed (value, nm_connection_get_path (priv->connection)); + g_value_set_string (value, nm_connection_get_path (NM_CONNECTION (priv->settings_connection))); break; case PROP_ID: - g_value_set_string (value, nm_connection_get_id (priv->connection)); + g_value_set_string (value, nm_connection_get_id (NM_CONNECTION (priv->settings_connection))); break; case PROP_UUID: - g_value_set_string (value, nm_connection_get_uuid (priv->connection)); + g_value_set_string (value, nm_connection_get_uuid (NM_CONNECTION (priv->settings_connection))); break; case PROP_TYPE: - g_value_set_string (value, nm_connection_get_connection_type (priv->connection)); + g_value_set_string (value, nm_connection_get_connection_type (NM_CONNECTION (priv->settings_connection))); break; case PROP_SPECIFIC_OBJECT: - g_value_set_boxed (value, priv->specific_object ? priv->specific_object : "/"); + g_value_set_string (value, priv->specific_object ? priv->specific_object : "/"); break; case PROP_DEVICES: - devices = g_ptr_array_sized_new (1); + devices = g_ptr_array_sized_new (2); if (priv->device && priv->state < NM_ACTIVE_CONNECTION_STATE_DEACTIVATED) - g_ptr_array_add (devices, g_strdup (nm_device_get_path (priv->device))); - g_value_take_boxed (value, devices); + g_ptr_array_add (devices, g_strdup (nm_exported_object_get_path (NM_EXPORTED_OBJECT (priv->device)))); + g_ptr_array_add (devices, NULL); + g_value_take_boxed (value, (char **) g_ptr_array_free (devices, FALSE)); break; case PROP_STATE: if (priv->state_set) @@ -834,19 +911,19 @@ get_property (GObject *object, guint prop_id, break; case PROP_IP4_CONFIG: /* The IP and DHCP config properties may be overridden by a subclass */ - g_value_set_boxed (value, "/"); + g_value_set_string (value, "/"); break; case PROP_DHCP4_CONFIG: - g_value_set_boxed (value, "/"); + g_value_set_string (value, "/"); break; case PROP_DEFAULT6: g_value_set_boolean (value, priv->is_default6); break; case PROP_IP6_CONFIG: - g_value_set_boxed (value, "/"); + g_value_set_string (value, "/"); break; case PROP_DHCP6_CONFIG: - g_value_set_boxed (value, "/"); + g_value_set_string (value, "/"); break; case PROP_VPN: g_value_set_boolean (value, priv->vpn); @@ -854,7 +931,7 @@ get_property (GObject *object, guint prop_id, case PROP_MASTER: if (priv->master) master_device = nm_active_connection_get_device (priv->master); - g_value_set_boxed (value, master_device ? nm_device_get_path (master_device) : "/"); + nm_utils_g_value_set_object_path (value, master_device); break; case PROP_INT_SUBJECT: g_value_set_object (value, priv->subject); @@ -893,17 +970,18 @@ dispose (GObject *object) NMActiveConnection *self = NM_ACTIVE_CONNECTION (object); NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (self); + _LOGD ("disposing"); + if (priv->chain) { nm_auth_chain_unref (priv->chain); priv->chain = NULL; } - g_free (priv->path); - priv->path = NULL; g_free (priv->specific_object); priv->specific_object = NULL; - g_clear_object (&priv->connection); + g_clear_object (&priv->settings_connection); + g_clear_object (&priv->applied_connection); _device_cleanup (self); @@ -922,9 +1000,12 @@ static void nm_active_connection_class_init (NMActiveConnectionClass *ac_class) { GObjectClass *object_class = G_OBJECT_CLASS (ac_class); + NMExportedObjectClass *exported_object_class = NM_EXPORTED_OBJECT_CLASS (ac_class); g_type_class_add_private (ac_class, sizeof (NMActiveConnectionPrivate)); + exported_object_class->export_path = NM_DBUS_PATH "/ActiveConnection/%u"; + /* virtual methods */ object_class->get_property = get_property; object_class->set_property = set_property; @@ -934,10 +1015,10 @@ nm_active_connection_class_init (NMActiveConnectionClass *ac_class) /* D-Bus exported properties */ g_object_class_install_property (object_class, PROP_CONNECTION, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_CONNECTION, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_CONNECTION, "", "", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_ID, @@ -962,15 +1043,15 @@ nm_active_connection_class_init (NMActiveConnectionClass *ac_class) g_object_class_install_property (object_class, PROP_SPECIFIC_OBJECT, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT, "", "", + NULL, + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_DEVICES, g_param_spec_boxed (NM_ACTIVE_CONNECTION_DEVICES, "", "", - DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH, + G_TYPE_STRV, G_PARAM_READABLE | G_PARAM_STATIC_STRINGS)); @@ -992,17 +1073,17 @@ nm_active_connection_class_init (NMActiveConnectionClass *ac_class) g_object_class_install_property (object_class, PROP_IP4_CONFIG, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_IP4_CONFIG, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_IP4_CONFIG, "", "", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_DHCP4_CONFIG, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_DHCP4_CONFIG, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_DHCP4_CONFIG, "", "", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_DEFAULT6, @@ -1013,17 +1094,17 @@ nm_active_connection_class_init (NMActiveConnectionClass *ac_class) g_object_class_install_property (object_class, PROP_IP6_CONFIG, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_IP6_CONFIG, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_IP6_CONFIG, "", "", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_DHCP6_CONFIG, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_DHCP6_CONFIG, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_DHCP6_CONFIG, "", "", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_VPN, @@ -1034,24 +1115,24 @@ nm_active_connection_class_init (NMActiveConnectionClass *ac_class) g_object_class_install_property (object_class, PROP_MASTER, - g_param_spec_boxed (NM_ACTIVE_CONNECTION_MASTER, "", "", - DBUS_TYPE_G_OBJECT_PATH, - G_PARAM_READABLE | - G_PARAM_STATIC_STRINGS)); + g_param_spec_string (NM_ACTIVE_CONNECTION_MASTER, "", "", + NULL, + G_PARAM_READABLE | + G_PARAM_STATIC_STRINGS)); /* Internal properties */ g_object_class_install_property - (object_class, PROP_INT_CONNECTION, - g_param_spec_object (NM_ACTIVE_CONNECTION_INT_CONNECTION, "", "", - NM_TYPE_CONNECTION, - G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | + (object_class, PROP_INT_SETTINGS_CONNECTION, + g_param_spec_object (NM_ACTIVE_CONNECTION_INT_SETTINGS_CONNECTION, "", "", + NM_TYPE_SETTINGS_CONNECTION, + G_PARAM_WRITABLE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); g_object_class_install_property (object_class, PROP_INT_DEVICE, g_param_spec_object (NM_ACTIVE_CONNECTION_INT_DEVICE, "", "", NM_TYPE_DEVICE, - G_PARAM_READWRITE | + G_PARAM_READWRITE | G_PARAM_CONSTRUCT_ONLY | G_PARAM_STATIC_STRINGS)); g_object_class_install_property @@ -1090,8 +1171,8 @@ nm_active_connection_class_init (NMActiveConnectionClass *ac_class) NULL, NULL, NULL, G_TYPE_NONE, 1, G_TYPE_UINT); - nm_dbus_manager_register_exported_type (nm_dbus_manager_get (), - G_TYPE_FROM_CLASS (ac_class), - &dbus_glib_nm_active_connection_object_info); + nm_exported_object_class_add_interface (NM_EXPORTED_OBJECT_CLASS (ac_class), + NMDBUS_TYPE_ACTIVE_CONNECTION_SKELETON, + NULL); } |