fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2025-12-29 11:30:12 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions
NetworkManager/src/libnm-client-impl/nm-active-connection.c
Thomas Haller 615221a99c format: reformat source tree with clang-format 13.0 
We use clang-format for automatic formatting of our source files.
Since clang-format is actively maintained software, the actual
formatting depends on the used version of clang-format. That is
unfortunate and painful, but really unavoidable unless clang-format
would be strictly bug-compatible.

So the version that we must use is from the current Fedora release, which
is also tested by our gitlab-ci. Previously, we were using Fedora 34 with
clang-tools-extra-12.0.1-1.fc34.x86_64.

As Fedora 35 comes along, we need to update our formatting as Fedora 35
comes with version "13.0.0~rc1-1.fc35".
An alternative would be to freeze on version 12, but that has different
problems (like, it's cumbersome to rebuild clang 12 on Fedora 35 and it
would be cumbersome for our developers which are on Fedora 35 to use a
clang that they cannot easily install).

The (differently painful) solution is to reformat from time to time, as we
switch to a new Fedora (and thus clang) version.
Usually we would expect that such a reformatting brings minor changes.
But this time, the changes are huge. That is mentioned in the release
notes [1] as

  Makes PointerAligment: Right working with AlignConsecutiveDeclarations. (Fixes https://llvm.org/PR27353)

[1] https://releases.llvm.org/13.0.0/tools/clang/docs/ReleaseNotes.html#clang-format
2021-11-29 09:31:09 +00:00

839 lines
30 KiB
C
Raw Blame History

/* SPDX-License-Identifier: LGPL-2.1-or-later */
/*
* Copyright (C) 2007 - 2014 Red Hat, Inc.
* Copyright (C) 2008 Novell, Inc.
*/
#include "libnm-client-impl/nm-default-libnm.h"
#include "nm-active-connection.h"
#include "nm-dbus-interface.h"
#include "nm-object-private.h"
#include "libnm-core-intern/nm-core-internal.h"
#include "nm-device.h"
#include "nm-connection.h"
#include "nm-vpn-connection.h"
#include "nm-dbus-helpers.h"
#include "nm-dhcp4-config.h"
#include "nm-dhcp6-config.h"
#include "nm-ip4-config.h"
#include "nm-ip6-config.h"
#include "nm-remote-connection.h"
/*****************************************************************************/
NM_GOBJECT_PROPERTIES_DEFINE(NMActiveConnection,
PROP_CONNECTION,
PROP_ID,
PROP_UUID,
PROP_TYPE,
PROP_SPECIFIC_OBJECT_PATH,
PROP_DEVICES,
PROP_STATE,
PROP_STATE_FLAGS,
PROP_DEFAULT,
PROP_IP4_CONFIG,
PROP_DHCP4_CONFIG,
PROP_DEFAULT6,
PROP_IP6_CONFIG,
PROP_DHCP6_CONFIG,
PROP_VPN,
PROP_MASTER, );
enum {
STATE_CHANGED,
LAST_SIGNAL
};
static guint signals[LAST_SIGNAL];
enum {
PROPERTY_O_IDX_CONNECTION,
PROPERTY_O_IDX_MASTER,
PROPERTY_O_IDX_IP4_CONFIG,
PROPERTY_O_IDX_IP6_CONFIG,
PROPERTY_O_IDX_DHCP4_CONFIG,
PROPERTY_O_IDX_DHCP6_CONFIG,
_PROPERTY_O_IDX_NUM,
};
typedef struct _NMActiveConnectionPrivate {
NMLDBusPropertyO property_o[_PROPERTY_O_IDX_NUM];
NMLDBusPropertyAO devices;
NMRefString *specific_object_path;
char *id;
char *uuid;
char *type;
guint32 state;
guint32 state_flags;
bool is_default;
bool is_default6;
bool is_vpn;
guint32 reason;
} NMActiveConnectionPrivate;
G_DEFINE_TYPE(NMActiveConnection, nm_active_connection, NM_TYPE_OBJECT);
#define NM_ACTIVE_CONNECTION_GET_PRIVATE(self) \
_NM_GET_PRIVATE_PTR(self, NMActiveConnection, NM_IS_ACTIVE_CONNECTION, NMObject)
/*****************************************************************************/
/**
* nm_active_connection_get_connection:
* @connection: a #NMActiveConnection
*
* Gets the #NMRemoteConnection associated with @connection.
*
* Returns: (transfer none): the #NMRemoteConnection which this
* #NMActiveConnection is an active instance of.
**/
NMRemoteConnection *
nm_active_connection_get_connection(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_o_get_obj(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->property_o[PROPERTY_O_IDX_CONNECTION]);
}
/**
* nm_active_connection_get_id:
* @connection: a #NMActiveConnection
*
* Gets the #NMConnection's ID.
*
* Returns: the ID of the #NMConnection that backs the #NMActiveConnection.
* This is the internal string used by the connection, and must not be modified.
**/
const char *
nm_active_connection_get_id(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return _nml_coerce_property_str_not_empty(NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->id);
}
/**
* nm_active_connection_get_uuid:
* @connection: a #NMActiveConnection
*
* Gets the #NMConnection's UUID.
*
* Returns: the UUID of the #NMConnection that backs the #NMActiveConnection.
* This is the internal string used by the connection, and must not be modified.
**/
const char *
nm_active_connection_get_uuid(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return _nml_coerce_property_str_not_empty(NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->uuid);
}
/**
* nm_active_connection_get_connection_type:
* @connection: a #NMActiveConnection
*
* Gets the #NMConnection's type.
*
* Returns: the type of the #NMConnection that backs the #NMActiveConnection.
* This is the internal string used by the connection, and must not be modified.
**/
const char *
nm_active_connection_get_connection_type(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return _nml_coerce_property_str_not_empty(NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->type);
}
/**
* nm_active_connection_get_specific_object_path:
* @connection: a #NMActiveConnection
*
* Gets the path of the "specific object" used at activation.
*
* Currently, there is no single method that will allow you to automatically turn
* this into an appropriate #NMObject; you need to know what kind of object it
* is based on other information. (Eg, if @connection corresponds to a Wi-Fi
* connection, then the specific object will be an #NMAccessPoint, and you can
* resolve it with nm_device_wifi_get_access_point_by_path().)
*
* Returns: the specific object's D-Bus path. This is the internal string used
* by the connection, and must not be modified.
**/
const char *
nm_active_connection_get_specific_object_path(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return _nml_coerce_property_object_path(
NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->specific_object_path);
}
/**
* nm_active_connection_get_devices:
* @connection: a #NMActiveConnection
*
* Gets the #NMDevices used for the active connections.
*
* Returns: (element-type NMDevice): the #GPtrArray containing #NMDevices.
* This is the internal copy used by the connection, and must not be modified.
**/
const GPtrArray *
nm_active_connection_get_devices(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_ao_get_objs_as_ptrarray(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->devices);
}
/**
* nm_active_connection_get_state:
* @connection: a #NMActiveConnection
*
* Gets the active connection's state.
*
* Returns: the state
**/
NMActiveConnectionState
nm_active_connection_get_state(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NM_ACTIVE_CONNECTION_STATE_UNKNOWN);
return NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->state;
}
/**
* nm_active_connection_get_state_flags:
* @connection: a #NMActiveConnection
*
* Gets the active connection's state flags.
*
* Returns: the state flags
*
* Since: 1.10
**/
NMActivationStateFlags
nm_active_connection_get_state_flags(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NM_ACTIVATION_STATE_FLAG_NONE);
return NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->state_flags;
}
/**
* nm_active_connection_get_state_reason:
* @connection: a #NMActiveConnection
*
* Gets the reason for active connection's state.
*
* Returns: the reason
*
* Since: 1.8
**/
NMActiveConnectionStateReason
nm_active_connection_get_state_reason(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection),
NM_ACTIVE_CONNECTION_STATE_REASON_UNKNOWN);
return NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->reason;
}
/**
* nm_active_connection_get_default:
* @connection: a #NMActiveConnection
*
* Whether the active connection is the default IPv4 one (that is, is used for
* the default IPv4 route and DNS information).
*
* Returns: %TRUE if the active connection is the default IPv4 connection
**/
gboolean
nm_active_connection_get_default(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), FALSE);
return NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->is_default;
}
/**
* nm_active_connection_get_ip4_config:
* @connection: an #NMActiveConnection
*
* Gets the current IPv4 #NMIPConfig associated with the #NMActiveConnection.
*
* Returns: (transfer none): the IPv4 #NMIPConfig, or %NULL if the connection is
* not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
**/
NMIPConfig *
nm_active_connection_get_ip4_config(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_o_get_obj(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->property_o[PROPERTY_O_IDX_IP4_CONFIG]);
}
/**
* nm_active_connection_get_dhcp4_config:
* @connection: an #NMActiveConnection
*
* Gets the current IPv4 #NMDhcpConfig (if any) associated with the
* #NMActiveConnection.
*
* Returns: (transfer none): the IPv4 #NMDhcpConfig, or %NULL if the connection
* does not use DHCP, or is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED
* state.
**/
NMDhcpConfig *
nm_active_connection_get_dhcp4_config(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_o_get_obj(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->property_o[PROPERTY_O_IDX_DHCP4_CONFIG]);
}
/**
* nm_active_connection_get_default6:
* @connection: a #NMActiveConnection
*
* Whether the active connection is the default IPv6 one (that is, is used for
* the default IPv6 route and DNS information).
*
* Returns: %TRUE if the active connection is the default IPv6 connection
**/
gboolean
nm_active_connection_get_default6(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), FALSE);
return NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->is_default6;
}
/**
* nm_active_connection_get_ip6_config:
* @connection: an #NMActiveConnection
*
* Gets the current IPv6 #NMIPConfig associated with the #NMActiveConnection.
*
* Returns: (transfer none): the IPv6 #NMIPConfig, or %NULL if the connection is
* not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED state.
**/
NMIPConfig *
nm_active_connection_get_ip6_config(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_o_get_obj(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->property_o[PROPERTY_O_IDX_IP6_CONFIG]);
}
/**
* nm_active_connection_get_dhcp6_config:
* @connection: an #NMActiveConnection
*
* Gets the current IPv6 #NMDhcpConfig (if any) associated with the
* #NMActiveConnection.
*
* Returns: (transfer none): the IPv6 #NMDhcpConfig, or %NULL if the connection
* does not use DHCPv6, or is not in the %NM_ACTIVE_CONNECTION_STATE_ACTIVATED
* state.
**/
NMDhcpConfig *
nm_active_connection_get_dhcp6_config(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_o_get_obj(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->property_o[PROPERTY_O_IDX_DHCP6_CONFIG]);
}
/**
* nm_active_connection_get_vpn:
* @connection: a #NMActiveConnection
*
* Whether the active connection is a VPN connection.
*
* Returns: %TRUE if the active connection is a VPN connection
**/
gboolean
nm_active_connection_get_vpn(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), FALSE);
return NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->is_vpn;
}
/**
* nm_active_connection_get_master:
* @connection: a #NMActiveConnection
*
* Gets the master #NMDevice of the connection.
*
* Returns: (transfer none): the master #NMDevice of the #NMActiveConnection.
**/
NMDevice *
nm_active_connection_get_master(NMActiveConnection *connection)
{
g_return_val_if_fail(NM_IS_ACTIVE_CONNECTION(connection), NULL);
return nml_dbus_property_o_get_obj(
&NM_ACTIVE_CONNECTION_GET_PRIVATE(connection)->property_o[PROPERTY_O_IDX_MASTER]);
}
/*****************************************************************************/
static void
_notify_event_state_changed(NMClient *client, NMClientNotifyEventWithPtr *notify_event)
{
gs_unref_object NMActiveConnection *self = notify_event->user_data;
NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE(self);
/* we expose here the value cache in @priv. In practice, this is the same
* value as we received from the signal. In the unexpected case where they
* differ, the cached value of the current instance would still be more correct. */
g_signal_emit(self, signals[STATE_CHANGED], 0, (guint) priv->state, (guint) priv->reason);
}
void
_nm_active_connection_state_changed_commit(NMActiveConnection *self, guint32 state, guint32 reason)
{
NMClient *client;
NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE(self);
client = _nm_object_get_client(self);
if (priv->state != state) {
priv->state = state;
_nm_client_queue_notify_object(client, self, obj_properties[PROP_STATE]);
}
priv->reason = reason;
_nm_client_notify_event_queue_with_ptr(client,
NM_CLIENT_NOTIFY_EVENT_PRIO_GPROP + 1,
_notify_event_state_changed,
g_object_ref(self));
}
/*****************************************************************************/
static gboolean
is_ready(NMObject *nmobj)
{
NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE(nmobj);
/* Usually, we don't want to expose our NMObject instances until they are fully initialized.
* For NMRemoteSetting this means to wait until GetSettings() returns.
*
* Note that most object types reference each other (directly or indirectly). E.g. the
* NMActiveConnection refers to the NMRemoteConnection and the NMDevice instance. So,
* we don't want to hide them too long, otherwise basically the entire set of objects
* will be hidden until they are all initialized. So, usually, when a NMObject references
* objects that are not yet initialized, that reference will just be NULL but the object
* will be considered ready already.
*
* For NMActiveConnection referencing a NMRemoteConnection don't do that. Here we wait for the
* NMRemoteConnection to be ready as well. This is somewhat arbitrary special casing, but
* the effect is that when nm_client_add_and_activate*() returns, the NMActiveConnection already
* references a initialized NMRemoteConnection.
*/
if (!nml_dbus_property_o_is_ready_fully(&priv->property_o[PROPERTY_O_IDX_CONNECTION]))
return FALSE;
return NM_OBJECT_CLASS(nm_active_connection_parent_class)->is_ready(nmobj);
}
/*****************************************************************************/
static void
nm_active_connection_init(NMActiveConnection *self)
{
NMActiveConnectionPrivate *priv;
priv = G_TYPE_INSTANCE_GET_PRIVATE(self, NM_TYPE_ACTIVE_CONNECTION, NMActiveConnectionPrivate);
self->_priv = priv;
}
static void
finalize(GObject *object)
{
NMActiveConnectionPrivate *priv = NM_ACTIVE_CONNECTION_GET_PRIVATE(object);
g_free(priv->id);
g_free(priv->uuid);
g_free(priv->type);
nm_ref_string_unref(priv->specific_object_path);
G_OBJECT_CLASS(nm_active_connection_parent_class)->finalize(object);
}
static void
get_property(GObject *object, guint prop_id, GValue *value, GParamSpec *pspec)
{
NMActiveConnection *self = NM_ACTIVE_CONNECTION(object);
switch (prop_id) {
case PROP_CONNECTION:
g_value_set_object(value, nm_active_connection_get_connection(self));
break;
case PROP_ID:
g_value_set_string(value, nm_active_connection_get_id(self));
break;
case PROP_UUID:
g_value_set_string(value, nm_active_connection_get_uuid(self));
break;
case PROP_TYPE:
g_value_set_string(value, nm_active_connection_get_connection_type(self));
break;
case PROP_SPECIFIC_OBJECT_PATH:
g_value_set_string(value, nm_active_connection_get_specific_object_path(self));
break;
case PROP_DEVICES:
g_value_take_boxed(value,
_nm_utils_copy_object_array(nm_active_connection_get_devices(self)));
break;
case PROP_STATE:
g_value_set_enum(value, nm_active_connection_get_state(self));
break;
case PROP_STATE_FLAGS:
g_value_set_uint(value, nm_active_connection_get_state_flags(self));
break;
case PROP_DEFAULT:
g_value_set_boolean(value, nm_active_connection_get_default(self));
break;
case PROP_IP4_CONFIG:
g_value_set_object(value, nm_active_connection_get_ip4_config(self));
break;
case PROP_DHCP4_CONFIG:
g_value_set_object(value, nm_active_connection_get_dhcp4_config(self));
break;
case PROP_DEFAULT6:
g_value_set_boolean(value, nm_active_connection_get_default6(self));
break;
case PROP_IP6_CONFIG:
g_value_set_object(value, nm_active_connection_get_ip6_config(self));
break;
case PROP_DHCP6_CONFIG:
g_value_set_object(value, nm_active_connection_get_dhcp6_config(self));
break;
case PROP_VPN:
g_value_set_boolean(value, nm_active_connection_get_vpn(self));
break;
case PROP_MASTER:
g_value_set_object(value, nm_active_connection_get_master(self));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID(object, prop_id, pspec);
break;
}
}
const NMLDBusMetaIface _nml_dbus_meta_iface_nm_connection_active = NML_DBUS_META_IFACE_INIT_PROP(
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
nm_active_connection_get_type,
NML_DBUS_META_INTERFACE_PRIO_INSTANTIATE_10,
NML_DBUS_META_IFACE_DBUS_PROPERTIES(
NML_DBUS_META_PROPERTY_INIT_O_PROP("Connection",
PROP_CONNECTION,
NMActiveConnectionPrivate,
property_o[PROPERTY_O_IDX_CONNECTION],
nm_remote_connection_get_type),
NML_DBUS_META_PROPERTY_INIT_B("Default",
PROP_DEFAULT,
NMActiveConnectionPrivate,
is_default),
NML_DBUS_META_PROPERTY_INIT_B("Default6",
PROP_DEFAULT6,
NMActiveConnectionPrivate,
is_default6),
NML_DBUS_META_PROPERTY_INIT_AO_PROP("Devices",
PROP_DEVICES,
NMActiveConnectionPrivate,
devices,
nm_device_get_type),
NML_DBUS_META_PROPERTY_INIT_O_PROP("Dhcp4Config",
PROP_DHCP4_CONFIG,
NMActiveConnectionPrivate,
property_o[PROPERTY_O_IDX_DHCP4_CONFIG],
nm_dhcp4_config_get_type),
NML_DBUS_META_PROPERTY_INIT_O_PROP("Dhcp6Config",
PROP_DHCP6_CONFIG,
NMActiveConnectionPrivate,
property_o[PROPERTY_O_IDX_DHCP6_CONFIG],
nm_dhcp6_config_get_type),
NML_DBUS_META_PROPERTY_INIT_S("Id", PROP_ID, NMActiveConnectionPrivate, id),
NML_DBUS_META_PROPERTY_INIT_O_PROP("Ip4Config",
PROP_IP4_CONFIG,
NMActiveConnectionPrivate,
property_o[PROPERTY_O_IDX_IP4_CONFIG],
nm_ip4_config_get_type),
NML_DBUS_META_PROPERTY_INIT_O_PROP("Ip6Config",
PROP_IP6_CONFIG,
NMActiveConnectionPrivate,
property_o[PROPERTY_O_IDX_IP6_CONFIG],
nm_ip6_config_get_type),
NML_DBUS_META_PROPERTY_INIT_O_PROP("Master",
PROP_MASTER,
NMActiveConnectionPrivate,
property_o[PROPERTY_O_IDX_MASTER],
nm_device_get_type),
NML_DBUS_META_PROPERTY_INIT_O("SpecificObject",
PROP_SPECIFIC_OBJECT_PATH,
NMActiveConnectionPrivate,
specific_object_path),
NML_DBUS_META_PROPERTY_INIT_U("State", PROP_STATE, NMActiveConnectionPrivate, state),
NML_DBUS_META_PROPERTY_INIT_U("StateFlags",
PROP_STATE_FLAGS,
NMActiveConnectionPrivate,
state_flags),
NML_DBUS_META_PROPERTY_INIT_S("Type", PROP_TYPE, NMActiveConnectionPrivate, type),
NML_DBUS_META_PROPERTY_INIT_S("Uuid", PROP_UUID, NMActiveConnectionPrivate, uuid),
NML_DBUS_META_PROPERTY_INIT_B("Vpn", PROP_VPN, NMActiveConnectionPrivate, is_vpn), ),
.base_struct_offset = G_STRUCT_OFFSET(NMActiveConnection, _priv), );
static void
nm_active_connection_class_init(NMActiveConnectionClass *klass)
{
GObjectClass *object_class = G_OBJECT_CLASS(klass);
NMObjectClass *nm_object_class = NM_OBJECT_CLASS(klass);
g_type_class_add_private(klass, sizeof(NMActiveConnectionPrivate));
object_class->get_property = get_property;
object_class->finalize = finalize;
nm_object_class->is_ready = is_ready;
_NM_OBJECT_CLASS_INIT_PRIV_PTR_INDIRECT(nm_object_class, NMActiveConnection);
_NM_OBJECT_CLASS_INIT_PROPERTY_O_FIELDS_N(nm_object_class,
NMActiveConnectionPrivate,
property_o);
_NM_OBJECT_CLASS_INIT_PROPERTY_AO_FIELDS_1(nm_object_class, NMActiveConnectionPrivate, devices);
/**
* NMActiveConnection:connection:
*
* The connection that this is an active instance of.
**/
obj_properties[PROP_CONNECTION] =
g_param_spec_object(NM_ACTIVE_CONNECTION_CONNECTION,
"",
"",
NM_TYPE_REMOTE_CONNECTION,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:id:
*
* The active connection's ID
**/
obj_properties[PROP_ID] = g_param_spec_string(NM_ACTIVE_CONNECTION_ID,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:uuid:
*
* The active connection's UUID
**/
obj_properties[PROP_UUID] = g_param_spec_string(NM_ACTIVE_CONNECTION_UUID,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:type:
*
* The active connection's type
**/
obj_properties[PROP_TYPE] = g_param_spec_string(NM_ACTIVE_CONNECTION_TYPE,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:specific-object-path:
*
* The path to the "specific object" of the active connection; see
* nm_active_connection_get_specific_object_path() for more details.
**/
obj_properties[PROP_SPECIFIC_OBJECT_PATH] =
g_param_spec_string(NM_ACTIVE_CONNECTION_SPECIFIC_OBJECT_PATH,
"",
"",
NULL,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:devices: (type GPtrArray(NMDevice))
*
* The devices of the active connection.
**/
obj_properties[PROP_DEVICES] = g_param_spec_boxed(NM_ACTIVE_CONNECTION_DEVICES,
"",
"",
G_TYPE_PTR_ARRAY,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:state:
*
* The state of the active connection.
**/
obj_properties[PROP_STATE] = g_param_spec_enum(NM_ACTIVE_CONNECTION_STATE,
"",
"",
NM_TYPE_ACTIVE_CONNECTION_STATE,
NM_ACTIVE_CONNECTION_STATE_UNKNOWN,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:state-flags:
*
* The state flags of the active connection.
*
* Since: 1.10
**/
obj_properties[PROP_STATE_FLAGS] = g_param_spec_uint(NM_ACTIVE_CONNECTION_STATE_FLAGS,
"",
"",
0,
G_MAXUINT32,
NM_ACTIVATION_STATE_FLAG_NONE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:default:
*
* Whether the active connection is the default IPv4 one.
**/
obj_properties[PROP_DEFAULT] = g_param_spec_boolean(NM_ACTIVE_CONNECTION_DEFAULT,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:ip4-config:
*
* The IPv4 #NMIPConfig of the connection.
**/
obj_properties[PROP_IP4_CONFIG] =
g_param_spec_object(NM_ACTIVE_CONNECTION_IP4_CONFIG,
"",
"",
NM_TYPE_IP_CONFIG,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:dhcp4-config:
*
* The IPv4 #NMDhcpConfig of the connection.
**/
obj_properties[PROP_DHCP4_CONFIG] =
g_param_spec_object(NM_ACTIVE_CONNECTION_DHCP4_CONFIG,
"",
"",
NM_TYPE_DHCP_CONFIG,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:default6:
*
* Whether the active connection is the default IPv6 one.
**/
obj_properties[PROP_DEFAULT6] = g_param_spec_boolean(NM_ACTIVE_CONNECTION_DEFAULT6,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:ip6-config:
*
* The IPv6 #NMIPConfig of the connection.
**/
obj_properties[PROP_IP6_CONFIG] =
g_param_spec_object(NM_ACTIVE_CONNECTION_IP6_CONFIG,
"",
"",
NM_TYPE_IP_CONFIG,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:dhcp6-config:
*
* The IPv6 #NMDhcpConfig of the connection.
**/
obj_properties[PROP_DHCP6_CONFIG] =
g_param_spec_object(NM_ACTIVE_CONNECTION_DHCP6_CONFIG,
"",
"",
NM_TYPE_DHCP_CONFIG,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:vpn:
*
* Whether the active connection is a VPN connection.
**/
obj_properties[PROP_VPN] = g_param_spec_boolean(NM_ACTIVE_CONNECTION_VPN,
"",
"",
FALSE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
/**
* NMActiveConnection:master:
*
* The master device if one exists.
**/
obj_properties[PROP_MASTER] = g_param_spec_object(NM_ACTIVE_CONNECTION_MASTER,
"",
"",
NM_TYPE_DEVICE,
G_PARAM_READABLE | G_PARAM_STATIC_STRINGS);
_nml_dbus_meta_class_init_with_properties(object_class,
&_nml_dbus_meta_iface_nm_connection_active);
/* TODO: the state reason should also be exposed as a property in libnm's NMActiveConnection,
* like done for NMDevice's state reason. */
/* TODO: the D-Bus API should also expose the state-reason as a property instead of
* a "StateChanged" signal. Like done for Device's "StateReason". */
/**
* NMActiveConnection::state-changed:
* @active_connection: the source #NMActiveConnection
* @state: the new state number (#NMActiveConnectionState)
* @reason: the state change reason (#NMActiveConnectionStateReason)
*/
signals[STATE_CHANGED] = g_signal_new("state-changed",
G_OBJECT_CLASS_TYPE(object_class),
G_SIGNAL_RUN_FIRST,
0,
NULL,
NULL,
NULL,
G_TYPE_NONE,
2,
G_TYPE_UINT,
G_TYPE_UINT);
}
Reference in a new issue View git blame Copy permalink