system/NetworkManager
system/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager synced 2024-07-23 19:24:38 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

libnm-glib: simplify property getter methods

Browse source 
Rather than having every property getter method have code to fetch
that specific property's value, just call the new
_nm_object_ensure_inited() (which makes sure that we've read all the
property values on the object at least once), and then return the
cached value. (After we've read the initial property values, the
PropertiesChanged signal handler will ensure that the values are kept
up to date, so we can always just return cached property values after
that point.)

This then lets us get rid of _nm_object_get_property() and its
wrappers.
This commit is contained in:
Dan Winship 2012-01-19 18:23:28 -05:00 committed by Dan Williams
parent 2e48cc092c
commit 5afcee4693
18 changed files with 260 additions and 1298 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

117
libnm-glib/nm-access-point.c
View file

@ -113,19 +113,10 @@ nm_access_point_new (DBusGConnection *connection, const char *path)
NM80211ApFlags
nm_access_point_get_flags (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NM_802_11_AP_FLAGS_NONE);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->flags) {
priv->flags = _nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_FLAGS,
NULL);
}
return priv->flags;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->flags;
}
/**
@ -139,19 +130,10 @@ nm_access_point_get_flags (NMAccessPoint *ap)
NM80211ApSecurityFlags
nm_access_point_get_wpa_flags (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NM_802_11_AP_SEC_NONE);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->wpa_flags) {
priv->wpa_flags = _nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_WPA_FLAGS,
NULL);
}
return priv->wpa_flags;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->wpa_flags;
}
/**
@ -166,19 +148,10 @@ nm_access_point_get_wpa_flags (NMAccessPoint *ap)
NM80211ApSecurityFlags
nm_access_point_get_rsn_flags (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NM_802_11_AP_SEC_NONE);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->rsn_flags) {
priv->rsn_flags = _nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_RSN_FLAGS,
NULL);
}
return priv->rsn_flags;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->rsn_flags;
}
/**
@ -193,19 +166,10 @@ nm_access_point_get_rsn_flags (NMAccessPoint *ap)
const GByteArray *
nm_access_point_get_ssid (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->ssid) {
priv->ssid = _nm_object_get_byte_array_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_SSID,
NULL);
}
return priv->ssid;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->ssid;
}
/**
@ -219,19 +183,10 @@ nm_access_point_get_ssid (NMAccessPoint *ap)
guint32
nm_access_point_get_frequency (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->frequency) {
priv->frequency = _nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_FREQUENCY,
NULL);
}
return priv->frequency;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->frequency;
}
/**
@ -246,19 +201,10 @@ nm_access_point_get_frequency (NMAccessPoint *ap)
const char *
nm_access_point_get_bssid (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->bssid) {
priv->bssid = _nm_object_get_string_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_HW_ADDRESS,
NULL);
}
return priv->bssid;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->bssid;
}
/**
@ -289,19 +235,10 @@ nm_access_point_get_hw_address (NMAccessPoint *ap)
NM80211Mode
nm_access_point_get_mode (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->mode) {
priv->mode = _nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_MODE,
NULL);
}
return priv->mode;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->mode;
}
/**
@ -315,19 +252,10 @@ nm_access_point_get_mode (NMAccessPoint *ap)
guint32
nm_access_point_get_max_bitrate (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->max_bitrate) {
priv->max_bitrate = _nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_MAX_BITRATE,
NULL);
}
return priv->max_bitrate;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->max_bitrate;
}
/**
@ -341,19 +269,10 @@ nm_access_point_get_max_bitrate (NMAccessPoint *ap)
guint8
nm_access_point_get_strength (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->strength) {
priv->strength = _nm_object_get_byte_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_STRENGTH,
NULL);
}
return priv->strength;
_nm_object_ensure_inited (NM_OBJECT (ap));
return NM_ACCESS_POINT_GET_PRIVATE (ap)->strength;
}
/**

112
libnm-glib/nm-active-connection.c
View file

@ -107,19 +107,10 @@ nm_active_connection_new (DBusGConnection *connection, const char *path)
const char *
nm_active_connection_get_connection (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->connection) {
priv->connection = _nm_object_get_string_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_CONNECTION,
NULL);
}
return priv->connection;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->connection;
}
/**
@ -134,19 +125,10 @@ nm_active_connection_get_connection (NMActiveConnection *connection)
const char *
nm_active_connection_get_uuid (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->uuid) {
priv->uuid = _nm_object_get_string_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_UUID,
NULL);
}
return priv->uuid;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->uuid;
}
/**
@ -161,19 +143,10 @@ nm_active_connection_get_uuid (NMActiveConnection *connection)
const char *
nm_active_connection_get_specific_object (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->specific_object) {
priv->specific_object = _nm_object_get_string_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_SPECIFIC_OBJECT,
NULL);
}
return priv->specific_object;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->specific_object;
}
/**
@ -188,27 +161,10 @@ nm_active_connection_get_specific_object (NMActiveConnection *connection)
const GPtrArray *
nm_active_connection_get_devices (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (priv->devices)
return handle_ptr_array_return (priv->devices);
if (!_nm_object_get_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_DEVICES,
&value,
NULL)) {
return NULL;
}
demarshal_devices (NM_OBJECT (connection), NULL, &value, &priv->devices);
g_value_unset (&value);
return handle_ptr_array_return (priv->devices);
_nm_object_ensure_inited (NM_OBJECT (connection));
return handle_ptr_array_return (NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->devices);
}
/**
@ -222,19 +178,10 @@ nm_active_connection_get_devices (NMActiveConnection *connection)
NMActiveConnectionState
nm_active_connection_get_state (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NM_ACTIVE_CONNECTION_STATE_UNKNOWN);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->state) {
priv->state = _nm_object_get_uint_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_STATE,
NULL);
}
return priv->state;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->state;
}
/**
@ -249,19 +196,10 @@ nm_active_connection_get_state (NMActiveConnection *connection)
gboolean
nm_active_connection_get_default (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), FALSE);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->is_default) {
priv->is_default = _nm_object_get_boolean_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_DEFAULT,
NULL);
}
return priv->is_default;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->is_default;
}
/**
@ -276,19 +214,10 @@ nm_active_connection_get_default (NMActiveConnection *connection)
gboolean
nm_active_connection_get_default6 (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), FALSE);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->is_default6) {
priv->is_default6 = _nm_object_get_boolean_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_DEFAULT6,
NULL);
}
return priv->is_default6;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->is_default6;
}
/**
@ -303,19 +232,10 @@ nm_active_connection_get_default6 (NMActiveConnection *connection)
const char *
nm_active_connection_get_master (NMActiveConnection *connection)
{
NMActiveConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_ACTIVE_CONNECTION (connection), NULL);
priv = NM_ACTIVE_CONNECTION_GET_PRIVATE (connection);
if (!priv->master) {
priv->master = _nm_object_get_string_property (NM_OBJECT (connection),
NM_DBUS_INTERFACE_ACTIVE_CONNECTION,
DBUS_PROP_MASTER,
NULL);
}
return priv->master;
_nm_object_ensure_inited (NM_OBJECT (connection));
return NM_ACTIVE_CONNECTION_GET_PRIVATE (connection)->master;
}
static void

158
libnm-glib/nm-client.c
View file

@ -62,7 +62,6 @@ typedef struct {
*/
GSList *pending_activations;
gboolean have_networking_enabled;
gboolean networking_enabled;
gboolean wireless_enabled;
gboolean wireless_hw_enabled;
@ -110,18 +109,6 @@ static void proxy_name_owner_changed (DBusGProxy *proxy,
static void client_device_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
static void client_device_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
static void
handle_net_enabled_changed (GObject *object,
GParamSpec *pspec,
GValue *value,
gpointer user_data)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (object);
/* Update the cache flag when it changes */
priv->have_networking_enabled = TRUE;
}
static void
nm_client_init (NMClient *client)
{
@ -130,11 +117,6 @@ nm_client_init (NMClient *client)
priv->state = NM_STATE_UNKNOWN;
priv->permissions = g_hash_table_new (g_direct_hash, g_direct_equal);
g_signal_connect (client,
"notify::" NM_CLIENT_NETWORKING_ENABLED,
G_CALLBACK (handle_net_enabled_changed),
client);
}
static void
@ -155,29 +137,29 @@ static void
update_wireless_status (NMClient *client, gboolean notify)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
gboolean val;
gboolean oldval;
gboolean poke = FALSE;
val = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WirelessHardwareEnabled",
NULL);
if (val != priv->wireless_hw_enabled) {
priv->wireless_hw_enabled = val;
oldval = priv->wireless_hw_enabled;
_nm_object_reload_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WirelessHardwareEnabled");
if (oldval != priv->wireless_hw_enabled) {
poke = TRUE;
if (notify)
_nm_object_queue_notify (NM_OBJECT (client), NM_CLIENT_WIRELESS_HARDWARE_ENABLED);
}
if (priv->wireless_hw_enabled == FALSE)
val = FALSE;
else
val = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WirelessEnabled",
NULL);
if (val != priv->wireless_enabled) {
priv->wireless_enabled = val;
oldval = priv->wireless_enabled;
if (priv->wireless_hw_enabled == FALSE) {
priv->wireless_enabled = FALSE;
} else {
_nm_object_reload_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WirelessEnabled");
}
if (oldval != priv->wireless_enabled) {
poke = TRUE;
if (notify)
_nm_object_queue_notify (NM_OBJECT (client), NM_CLIENT_WIRELESS_ENABLED);
@ -197,29 +179,27 @@ static void
update_wwan_status (NMClient *client, gboolean notify)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
gboolean val;
gboolean oldval;
val = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WwanHardwareEnabled",
NULL);
if (val != priv->wwan_hw_enabled) {
priv->wwan_hw_enabled = val;
oldval = priv->wwan_hw_enabled;
_nm_object_reload_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WwanHardwareEnabled");
if (oldval != priv->wwan_hw_enabled) {
if (notify)
_nm_object_queue_notify (NM_OBJECT (client), NM_CLIENT_WWAN_HARDWARE_ENABLED);
}
if (priv->wwan_hw_enabled == FALSE)
val = FALSE;
else {
val = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WwanEnabled",
NULL);
oldval = priv->wwan_enabled;
if (priv->wwan_hw_enabled == FALSE) {
priv->wwan_enabled = FALSE;
} else {
_nm_object_reload_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WwanEnabled");
}
if (val != priv->wwan_enabled) {
priv->wwan_enabled = val;
if (oldval != priv->wwan_enabled) {
if (notify)
_nm_object_queue_notify (NM_OBJECT (client), NM_CLIENT_WWAN_ENABLED);
}
@ -229,29 +209,27 @@ static void
update_wimax_status (NMClient *client, gboolean notify)
{
NMClientPrivate *priv = NM_CLIENT_GET_PRIVATE (client);
gboolean val;
gboolean oldval;
val = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WimaxHardwareEnabled",
NULL);
if (val != priv->wimax_hw_enabled) {
priv->wimax_hw_enabled = val;
oldval = priv->wimax_hw_enabled;
_nm_object_reload_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WimaxHardwareEnabled");
if (oldval != priv->wimax_hw_enabled) {
if (notify)
_nm_object_queue_notify (NM_OBJECT (client), NM_CLIENT_WIMAX_HARDWARE_ENABLED);
}
oldval = priv->wimax_enabled;
if (priv->wimax_hw_enabled == FALSE)
val = FALSE;
priv->wimax_enabled = FALSE;
else {
val = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WimaxEnabled",
NULL);
_nm_object_reload_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"WimaxEnabled");
}
if (val != priv->wimax_enabled) {
priv->wimax_enabled = val;
if (oldval != priv->wimax_enabled) {
if (notify)
_nm_object_queue_notify (NM_OBJECT (client), NM_CLIENT_WIMAX_ENABLED);
}
@ -877,28 +855,14 @@ const GPtrArray *
nm_client_get_active_connections (NMClient *client)
{
NMClientPrivate *priv;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
priv = NM_CLIENT_GET_PRIVATE (client);
if (priv->active_connections)
return handle_ptr_array_return (priv->active_connections);
if (!priv->manager_running)
return NULL;
if (!_nm_object_get_property (NM_OBJECT (client),
"org.freedesktop.NetworkManager",
"ActiveConnections",
&value,
NULL)) {
return NULL;
}
demarshal_active_connections (NM_OBJECT (client), NULL, &value, &priv->active_connections);
g_value_unset (&value);
_nm_object_ensure_inited (NM_OBJECT (client));
return handle_ptr_array_return (priv->active_connections);
}
@ -915,6 +879,7 @@ nm_client_wireless_get_enabled (NMClient *client)
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wireless_enabled;
}
@ -954,6 +919,7 @@ nm_client_wireless_hardware_get_enabled (NMClient *client)
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wireless_hw_enabled;
}
@ -970,6 +936,7 @@ nm_client_wwan_get_enabled (NMClient *client)
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wwan_enabled;
}
@ -1009,6 +976,7 @@ nm_client_wwan_hardware_get_enabled (NMClient *client)
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wwan_hw_enabled;
}
@ -1025,6 +993,7 @@ nm_client_wimax_get_enabled (NMClient *client)
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wimax_enabled;
}
@ -1064,6 +1033,7 @@ nm_client_wimax_hardware_get_enabled (NMClient *client)
{
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->wimax_hw_enabled;
}
@ -1079,7 +1049,6 @@ const char *
nm_client_get_version (NMClient *client)
{
NMClientPrivate *priv;
GError *err = NULL;
g_return_val_if_fail (NM_IS_CLIENT (client), NULL);
@ -1088,13 +1057,7 @@ nm_client_get_version (NMClient *client)
if (!priv->manager_running)
return NULL;
if (!priv->version)
priv->version = _nm_object_get_string_property (NM_OBJECT (client), NM_DBUS_INTERFACE, "Version", &err);
/* TODO: we don't pass the error to the caller yet, maybe later */
if (err)
g_error_free (err);
_nm_object_ensure_inited (NM_OBJECT (client));
return priv->version;
}
@ -1118,9 +1081,7 @@ nm_client_get_state (NMClient *client)
if (!priv->manager_running)
return NM_STATE_UNKNOWN;
if (priv->state == NM_STATE_UNKNOWN)
priv->state = _nm_object_get_uint_property (NM_OBJECT (client), NM_DBUS_INTERFACE, "State", NULL);
_nm_object_ensure_inited (NM_OBJECT (client));
return priv->state;
}
@ -1135,23 +1096,10 @@ nm_client_get_state (NMClient *client)
gboolean
nm_client_networking_get_enabled (NMClient *client)
{
NMClientPrivate *priv;
g_return_val_if_fail (NM_IS_CLIENT (client), FALSE);
priv = NM_CLIENT_GET_PRIVATE (client);
if (!priv->have_networking_enabled) {
priv = NM_CLIENT_GET_PRIVATE (client);
if (!priv->networking_enabled) {
priv->networking_enabled = _nm_object_get_boolean_property (NM_OBJECT (client),
NM_DBUS_INTERFACE,
"NetworkingEnabled",
NULL);
priv->have_networking_enabled = TRUE;
}
}
return priv->networking_enabled;
_nm_object_ensure_inited (NM_OBJECT (client));
return NM_CLIENT_GET_PRIVATE (client)->networking_enabled;
}
/**

41
libnm-glib/nm-device-bt.c
View file

@ -42,7 +42,6 @@ typedef struct {
char *hw_address;
char *name;
guint32 bt_capabilities;
gboolean bt_capabilities_valid;
gboolean disposed;
} NMDeviceBtPrivate;
@ -93,19 +92,10 @@ nm_device_bt_new (DBusGConnection *connection, const char *path)
const char *
nm_device_bt_get_hw_address (NMDeviceBt *device)
{
NMDeviceBtPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_BT (device), NULL);
priv = NM_DEVICE_BT_GET_PRIVATE (device);
if (!priv->hw_address) {
priv->hw_address = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_BLUETOOTH,
DBUS_PROP_HW_ADDRESS,
NULL);
}
return priv->hw_address;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BT_GET_PRIVATE (device)->hw_address;
}
/**
@ -119,19 +109,10 @@ nm_device_bt_get_hw_address (NMDeviceBt *device)
const char *
nm_device_bt_get_name (NMDeviceBt *device)
{
NMDeviceBtPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_BT (device), NULL);
priv = NM_DEVICE_BT_GET_PRIVATE (device);
if (!priv->name) {
priv->name = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_BLUETOOTH,
DBUS_PROP_NAME,
NULL);
}
return priv->name;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BT_GET_PRIVATE (device)->name;
}
/**
@ -145,20 +126,10 @@ nm_device_bt_get_name (NMDeviceBt *device)
NMBluetoothCapabilities
nm_device_bt_get_capabilities (NMDeviceBt *device)
{
NMDeviceBtPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_BT (device), NM_BT_CAPABILITY_NONE);
priv = NM_DEVICE_BT_GET_PRIVATE (device);
if (!priv->bt_capabilities_valid) {
priv->bt_capabilities = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_BLUETOOTH,
DBUS_PROP_BT_CAPABILITIES,
NULL);
priv->bt_capabilities_valid = TRUE;
}
return priv->bt_capabilities;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_BT_GET_PRIVATE (device)->bt_capabilities;
}
static NMBluetoothCapabilities

55
libnm-glib/nm-device-ethernet.c
View file

@ -44,7 +44,6 @@ typedef struct {
char *perm_hw_address;
guint32 speed;
gboolean carrier;
gboolean carrier_valid;
gboolean disposed;
} NMDeviceEthernetPrivate;
@ -97,19 +96,10 @@ nm_device_ethernet_new (DBusGConnection *connection, const char *path)
const char *
nm_device_ethernet_get_hw_address (NMDeviceEthernet *device)
{
NMDeviceEthernetPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL);
priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
if (!priv->hw_address) {
priv->hw_address = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRED,
DBUS_PROP_HW_ADDRESS,
NULL);
}
return priv->hw_address;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->hw_address;
}
/**
@ -124,19 +114,10 @@ nm_device_ethernet_get_hw_address (NMDeviceEthernet *device)
const char *
nm_device_ethernet_get_permanent_hw_address (NMDeviceEthernet *device)
{
NMDeviceEthernetPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL);
priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
if (!priv->perm_hw_address) {
priv->perm_hw_address = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRED,
DBUS_PROP_PERM_HW_ADDRESS,
NULL);
}
return priv->perm_hw_address;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->perm_hw_address;
}
/**
@ -150,19 +131,10 @@ nm_device_ethernet_get_permanent_hw_address (NMDeviceEthernet *device)
guint32
nm_device_ethernet_get_speed (NMDeviceEthernet *device)
{
NMDeviceEthernetPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), 0);
priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
if (!priv->speed) {
priv->speed = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRED,
DBUS_PROP_SPEED,
NULL);
}
return priv->speed;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->speed;
}
/**
@ -176,20 +148,10 @@ nm_device_ethernet_get_speed (NMDeviceEthernet *device)
gboolean
nm_device_ethernet_get_carrier (NMDeviceEthernet *device)
{
NMDeviceEthernetPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), FALSE);
priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
if (!priv->carrier_valid) {
priv->carrier = _nm_object_get_boolean_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRED,
DBUS_PROP_CARRIER,
NULL);
priv->carrier_valid = TRUE;
}
return priv->carrier;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->carrier;
}
static gboolean
@ -243,7 +205,6 @@ nm_device_ethernet_init (NMDeviceEthernet *device)
priv->disposed = FALSE;
priv->carrier = FALSE;
priv->carrier_valid = FALSE;
}
static void

29
libnm-glib/nm-device-infiniband.c
View file

@ -43,7 +43,6 @@ typedef struct {
char *hw_address;
gboolean carrier;
gboolean carrier_valid;
} NMDeviceInfinibandPrivate;
enum {
@ -90,19 +89,10 @@ nm_device_infiniband_new (DBusGConnection *connection, const char *path)
const char *
nm_device_infiniband_get_hw_address (NMDeviceInfiniband *device)
{
NMDeviceInfinibandPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_INFINIBAND (device), NULL);
priv = NM_DEVICE_INFINIBAND_GET_PRIVATE (device);
if (!priv->hw_address) {
priv->hw_address = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_INFINIBAND,
DBUS_PROP_HW_ADDRESS,
NULL);
}
return priv->hw_address;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_INFINIBAND_GET_PRIVATE (device)->hw_address;
}
/**
@ -116,20 +106,10 @@ nm_device_infiniband_get_hw_address (NMDeviceInfiniband *device)
gboolean
nm_device_infiniband_get_carrier (NMDeviceInfiniband *device)
{
NMDeviceInfinibandPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_INFINIBAND (device), FALSE);
priv = NM_DEVICE_INFINIBAND_GET_PRIVATE (device);
if (!priv->carrier_valid) {
priv->carrier = _nm_object_get_boolean_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_INFINIBAND,
DBUS_PROP_CARRIER,
NULL);
priv->carrier_valid = TRUE;
}
return priv->carrier;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_INFINIBAND_GET_PRIVATE (device)->carrier;
}
static gboolean
@ -171,7 +151,6 @@ nm_device_infiniband_init (NMDeviceInfiniband *device)
NMDeviceInfinibandPrivate *priv = NM_DEVICE_INFINIBAND_GET_PRIVATE (device);
priv->carrier = FALSE;
priv->carrier_valid = FALSE;
}
static void

26
libnm-glib/nm-device-modem.c
View file

@ -71,20 +71,11 @@ enum {
NMDeviceModemCapabilities
nm_device_modem_get_modem_capabilities (NMDeviceModem *self)
{
NMDeviceModemPrivate *priv;
g_return_val_if_fail (self != NULL, NM_DEVICE_MODEM_CAPABILITY_NONE);
g_return_val_if_fail (NM_IS_DEVICE_MODEM (self), NM_DEVICE_MODEM_CAPABILITY_NONE);
priv = NM_DEVICE_MODEM_GET_PRIVATE (self);
if (!priv->caps) {
priv->caps = _nm_object_get_uint_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_MODEM,
DBUS_PROP_MODEM_CAPS,
NULL);
}
return priv->caps;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_MODEM_GET_PRIVATE (self)->caps;
}
/**
@ -101,20 +92,11 @@ nm_device_modem_get_modem_capabilities (NMDeviceModem *self)
NMDeviceModemCapabilities
nm_device_modem_get_current_capabilities (NMDeviceModem *self)
{
NMDeviceModemPrivate *priv;
g_return_val_if_fail (self != NULL, NM_DEVICE_MODEM_CAPABILITY_NONE);
g_return_val_if_fail (NM_IS_DEVICE_MODEM (self), NM_DEVICE_MODEM_CAPABILITY_NONE);
priv = NM_DEVICE_MODEM_GET_PRIVATE (self);
if (!priv->current_caps) {
priv->current_caps = _nm_object_get_uint_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_MODEM,
DBUS_PROP_CURRENT_CAPS,
NULL);
}
return priv->current_caps;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_MODEM_GET_PRIVATE (self)->current_caps;
}
static gboolean

90
libnm-glib/nm-device-wifi.c
View file

@ -53,7 +53,6 @@ typedef struct {
NM80211Mode mode;
guint32 rate;
NMAccessPoint *active_ap;
gboolean got_active_ap;
NMDeviceWifiCapabilities wireless_caps;
GPtrArray *aps;
@ -121,19 +120,10 @@ nm_device_wifi_new (DBusGConnection *connection, const char *path)
const char *
nm_device_wifi_get_hw_address (NMDeviceWifi *device)
{
NMDeviceWifiPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
if (!priv->hw_address) {
priv->hw_address = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_HW_ADDRESS,
NULL);
}
return priv->hw_address;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->hw_address;
}
/**
@ -148,19 +138,10 @@ nm_device_wifi_get_hw_address (NMDeviceWifi *device)
const char *
nm_device_wifi_get_permanent_hw_address (NMDeviceWifi *device)
{
NMDeviceWifiPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
if (!priv->perm_hw_address) {
priv->perm_hw_address = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_PERM_HW_ADDRESS,
NULL);
}
return priv->perm_hw_address;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->perm_hw_address;
}
/**
@ -174,19 +155,10 @@ nm_device_wifi_get_permanent_hw_address (NMDeviceWifi *device)
NM80211Mode
nm_device_wifi_get_mode (NMDeviceWifi *device)
{
NMDeviceWifiPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
if (!priv->mode) {
priv->mode = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_MODE,
NULL);
}
return priv->mode;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->mode;
}
/**
@ -200,7 +172,6 @@ nm_device_wifi_get_mode (NMDeviceWifi *device)
guint32
nm_device_wifi_get_bitrate (NMDeviceWifi *device)
{
NMDeviceWifiPrivate *priv;
NMDeviceState state;
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
@ -217,15 +188,8 @@ nm_device_wifi_get_bitrate (NMDeviceWifi *device)
return 0;
}
priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
if (!priv->rate) {
priv->rate = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_BITRATE,
NULL);
}
return priv->rate;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->rate;
}
/**
@ -239,19 +203,10 @@ nm_device_wifi_get_bitrate (NMDeviceWifi *device)
NMDeviceWifiCapabilities
nm_device_wifi_get_capabilities (NMDeviceWifi *device)
{
NMDeviceWifiPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
if (!priv->wireless_caps) {
priv->wireless_caps = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_WIRELESS_CAPABILITIES,
NULL);
}
return priv->wireless_caps;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->wireless_caps;
}
/**
@ -265,11 +220,7 @@ nm_device_wifi_get_capabilities (NMDeviceWifi *device)
NMAccessPoint *
nm_device_wifi_get_active_access_point (NMDeviceWifi *device)
{
NMDeviceWifiPrivate *priv;
NMDeviceState state;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
@ -289,23 +240,8 @@ nm_device_wifi_get_active_access_point (NMDeviceWifi *device)
break;
}
priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
if (priv->got_active_ap == TRUE)
return priv->active_ap;
path = _nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_ACTIVE_ACCESS_POINT,
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_active_ap (NM_OBJECT (device), NULL, &value, &priv->active_ap);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->active_ap;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_WIFI_GET_PRIVATE (device)->active_ap;
}
/**
@ -652,8 +588,6 @@ demarshal_active_ap (NMObject *object, GParamSpec *pspec, GValue *value, gpointe
}
}
priv->got_active_ap = TRUE;
if (priv->active_ap) {
g_object_unref (priv->active_ap);
priv->active_ap = NULL;

99
libnm-glib/nm-device-wimax.c
View file

@ -48,7 +48,6 @@ typedef struct {
char *hw_address;
NMWimaxNsp *active_nsp;
gboolean got_active_nsp;
GPtrArray *nsps;
guint center_freq;
@ -121,19 +120,10 @@ nm_device_wimax_new (DBusGConnection *connection, const char *path)
const char *
nm_device_wimax_get_hw_address (NMDeviceWimax *wimax)
{
NMDeviceWimaxPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (wimax), NULL);
priv = NM_DEVICE_WIMAX_GET_PRIVATE (wimax);
if (!priv->hw_address) {
priv->hw_address = _nm_object_get_string_property (NM_OBJECT (wimax),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_HW_ADDRESS,
NULL);
}
return priv->hw_address;
_nm_object_ensure_inited (NM_OBJECT (wimax));
return NM_DEVICE_WIMAX_GET_PRIVATE (wimax)->hw_address;
}
/**
@ -147,11 +137,7 @@ nm_device_wimax_get_hw_address (NMDeviceWimax *wimax)
NMWimaxNsp *
nm_device_wimax_get_active_nsp (NMDeviceWimax *wimax)
{
NMDeviceWimaxPrivate *priv;
NMDeviceState state;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (wimax), NULL);
@ -171,23 +157,8 @@ nm_device_wimax_get_active_nsp (NMDeviceWimax *wimax)
break;
}
priv = NM_DEVICE_WIMAX_GET_PRIVATE (wimax);
if (priv->got_active_nsp == TRUE)
return priv->active_nsp;
path = _nm_object_get_object_path_property (NM_OBJECT (wimax),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_ACTIVE_NSP,
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_active_nsp (NM_OBJECT (wimax), NULL, &value, &priv->active_nsp);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->active_nsp;
_nm_object_ensure_inited (NM_OBJECT (wimax));
return NM_DEVICE_WIMAX_GET_PRIVATE (wimax)->active_nsp;
}
/**
@ -360,18 +331,10 @@ clean_up_nsps (NMDeviceWimax *self, gboolean notify)
guint
nm_device_wimax_get_center_frequency (NMDeviceWimax *self)
{
NMDeviceWimaxPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
if (!priv->center_freq) {
priv->center_freq = _nm_object_get_uint_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_CENTER_FREQUENCY,
NULL);
}
return priv->center_freq;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->center_freq;
}
/**
@ -388,18 +351,10 @@ nm_device_wimax_get_center_frequency (NMDeviceWimax *self)
gint
nm_device_wimax_get_rssi (NMDeviceWimax *self)
{
NMDeviceWimaxPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
if (!priv->rssi) {
priv->rssi = _nm_object_get_int_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_RSSI,
NULL);
}
return priv->rssi;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->rssi;
}
/**
@ -415,18 +370,10 @@ nm_device_wimax_get_rssi (NMDeviceWimax *self)
gint
nm_device_wimax_get_cinr (NMDeviceWimax *self)
{
NMDeviceWimaxPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
if (!priv->cinr) {
priv->cinr = _nm_object_get_int_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_CINR,
NULL);
}
return priv->cinr;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->cinr;
}
/**
@ -442,18 +389,10 @@ nm_device_wimax_get_cinr (NMDeviceWimax *self)
gint
nm_device_wimax_get_tx_power (NMDeviceWimax *self)
{
NMDeviceWimaxPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), 0);
priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
if (!priv->tx_power) {
priv->tx_power = _nm_object_get_int_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_TX_POWER,
NULL);
}
return priv->tx_power;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->tx_power;
}
/**
@ -467,18 +406,10 @@ nm_device_wimax_get_tx_power (NMDeviceWimax *self)
const char *
nm_device_wimax_get_bsid (NMDeviceWimax *self)
{
NMDeviceWimaxPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_WIMAX (self), NULL);
priv = NM_DEVICE_WIMAX_GET_PRIVATE (self);
if (!priv->bsid) {
priv->bsid = _nm_object_get_string_property (NM_OBJECT (self),
NM_DBUS_INTERFACE_DEVICE_WIMAX,
DBUS_PROP_BSID,
NULL);
}
return priv->bsid;
_nm_object_ensure_inited (NM_OBJECT (self));
return NM_DEVICE_WIMAX_GET_PRIVATE (self)->bsid;
}
static gboolean
@ -643,8 +574,6 @@ demarshal_active_nsp (NMObject *object, GParamSpec *pspec, GValue *value, gpoint
}
}
priv->got_active_nsp = TRUE;
if (priv->active_nsp) {
g_object_unref (priv->active_nsp);
priv->active_nsp = NULL;

245
libnm-glib/nm-device.c
View file

@ -56,17 +56,12 @@ typedef struct {
gboolean managed;
gboolean firmware_missing;
NMIP4Config *ip4_config;
gboolean got_ip4_config;
NMDHCP4Config *dhcp4_config;
gboolean got_dhcp4_config;
NMIP6Config *ip6_config;
gboolean got_ip6_config;
NMDHCP6Config *dhcp6_config;
gboolean got_dhcp6_config;
NMDeviceState state;
NMActiveConnection *active_connection;
gboolean got_active_connection;
GUdevClient *client;
char *product;
@ -134,8 +129,6 @@ demarshal_ip4_config (NMObject *object, GParamSpec *pspec, GValue *value, gpoint
}
}
priv->got_ip4_config = TRUE;
if (priv->ip4_config) {
g_object_unref (priv->ip4_config);
priv->ip4_config = NULL;
@ -170,8 +163,6 @@ demarshal_dhcp4_config (NMObject *object, GParamSpec *pspec, GValue *value, gpoi
}
}
priv->got_dhcp4_config = TRUE;
if (priv->dhcp4_config) {
g_object_unref (priv->dhcp4_config);
priv->dhcp4_config = NULL;
@ -206,8 +197,6 @@ demarshal_ip6_config (NMObject *object, GParamSpec *pspec, GValue *value, gpoint
}
}
priv->got_ip6_config = TRUE;
if (priv->ip6_config) {
g_object_unref (priv->ip6_config);
priv->ip6_config = NULL;
@ -242,8 +231,6 @@ demarshal_dhcp6_config (NMObject *object, GParamSpec *pspec, GValue *value, gpoi
}
}
priv->got_dhcp6_config = TRUE;
if (priv->dhcp6_config) {
g_object_unref (priv->dhcp6_config);
priv->dhcp6_config = NULL;
@ -278,8 +265,6 @@ demarshal_active_connection (NMObject *object, GParamSpec *pspec, GValue *value,
}
}
priv->got_active_connection = TRUE;
if (priv->active_connection) {
g_object_unref (priv->active_connection);
priv->active_connection = NULL;
@ -332,13 +317,9 @@ device_state_changed (DBusGProxy *proxy,
gpointer user_data)
{
NMDevice *self = NM_DEVICE (user_data);
NMDevicePrivate *priv = NM_DEVICE_GET_PRIVATE (self);
if (priv->state != new_state) {
priv->state = new_state;
if (old_state != new_state)
g_signal_emit (self, signals[STATE_CHANGED], 0, new_state, old_state, reason);
_nm_object_queue_notify (NM_OBJECT (self), "state");
}
}
static void
@ -906,19 +887,10 @@ out:
const char *
nm_device_get_iface (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->iface) {
priv->iface = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Interface",
NULL);
}
return priv->iface;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->iface;
}
/**
@ -934,19 +906,10 @@ nm_device_get_iface (NMDevice *device)
const char *
nm_device_get_ip_iface (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->ip_iface) {
priv->ip_iface = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"IpInterface",
NULL);
}
return priv->ip_iface;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->ip_iface;
}
/**
@ -978,19 +941,10 @@ nm_device_get_device_type (NMDevice *self)
const char *
nm_device_get_udi (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->udi) {
priv->udi = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Udi",
NULL);
}
return priv->udi;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->udi;
}
/**
@ -1005,19 +959,10 @@ nm_device_get_udi (NMDevice *device)
const char *
nm_device_get_driver (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->driver) {
priv->driver = _nm_object_get_string_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Driver",
NULL);
}
return priv->driver;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->driver;
}
/**
@ -1031,19 +976,10 @@ nm_device_get_driver (NMDevice *device)
NMDeviceCapabilities
nm_device_get_capabilities (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->capabilities) {
priv->capabilities = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Capabilities",
NULL);
}
return priv->capabilities;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->capabilities;
}
/**
@ -1057,19 +993,10 @@ nm_device_get_capabilities (NMDevice *device)
gboolean
nm_device_get_managed (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->managed) {
priv->managed = _nm_object_get_boolean_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Managed",
NULL);
}
return priv->managed;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->managed;
}
/**
@ -1085,19 +1012,10 @@ nm_device_get_managed (NMDevice *device)
gboolean
nm_device_get_firmware_missing (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), 0);
priv = NM_DEVICE_GET_PRIVATE (device);
if (!priv->firmware_missing) {
priv->firmware_missing = _nm_object_get_boolean_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"FirmwareMissing",
NULL);
}
return priv->firmware_missing;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->firmware_missing;
}
/**
@ -1111,30 +1029,10 @@ nm_device_get_firmware_missing (NMDevice *device)
NMIP4Config *
nm_device_get_ip4_config (NMDevice *device)
{
NMDevicePrivate *priv;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (priv->got_ip4_config == TRUE)
return priv->ip4_config;
path = _nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Ip4Config",
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_ip4_config (NM_OBJECT (device), NULL, &value, &priv->ip4_config);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->ip4_config;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->ip4_config;
}
/**
@ -1149,30 +1047,10 @@ nm_device_get_ip4_config (NMDevice *device)
NMDHCP4Config *
nm_device_get_dhcp4_config (NMDevice *device)
{
NMDevicePrivate *priv;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (priv->got_dhcp4_config == TRUE)
return priv->dhcp4_config;
path = _nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Dhcp4Config",
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_dhcp4_config (NM_OBJECT (device), NULL, &value, &priv->dhcp4_config);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->dhcp4_config;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->dhcp4_config;
}
/**
@ -1186,30 +1064,10 @@ nm_device_get_dhcp4_config (NMDevice *device)
NMIP6Config *
nm_device_get_ip6_config (NMDevice *device)
{
NMDevicePrivate *priv;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (priv->got_ip6_config == TRUE)
return priv->ip6_config;
path = _nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Ip6Config",
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_ip6_config (NM_OBJECT (device), NULL, &value, &priv->ip6_config);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->ip6_config;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->ip6_config;
}
/**
@ -1224,30 +1082,10 @@ nm_device_get_ip6_config (NMDevice *device)
NMDHCP6Config *
nm_device_get_dhcp6_config (NMDevice *device)
{
NMDevicePrivate *priv;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (priv->got_dhcp6_config == TRUE)
return priv->dhcp6_config;
path = _nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"Dhcp6Config",
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_dhcp6_config (NM_OBJECT (device), NULL, &value, &priv->dhcp6_config);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->dhcp6_config;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->dhcp6_config;
}
/**
@ -1261,19 +1099,10 @@ nm_device_get_dhcp6_config (NMDevice *device)
NMDeviceState
nm_device_get_state (NMDevice *device)
{
NMDevicePrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE (device), NM_DEVICE_STATE_UNKNOWN);
priv = NM_DEVICE_GET_PRIVATE (device);
if (priv->state == NM_DEVICE_STATE_UNKNOWN) {
priv->state = _nm_object_get_uint_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"State",
NULL);
}
return priv->state;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->state;
}
/**
@ -1288,30 +1117,10 @@ nm_device_get_state (NMDevice *device)
NMActiveConnection *
nm_device_get_active_connection (NMDevice *device)
{
NMDevicePrivate *priv;
char *path;
GValue value = { 0, };
GError *error = NULL;
g_return_val_if_fail (NM_IS_DEVICE (device), NULL);
priv = NM_DEVICE_GET_PRIVATE (device);
if (priv->got_active_connection == TRUE)
return priv->active_connection;
path = _nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE,
"ActiveConnection",
&error);
if (error == NULL) {
g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
g_value_take_boxed (&value, path);
demarshal_active_connection (NM_OBJECT (device), NULL, &value, &priv->active_connection);
g_value_unset (&value);
}
g_clear_error (&error);
return priv->active_connection;
_nm_object_ensure_inited (NM_OBJECT (device));
return NM_DEVICE_GET_PRIVATE (device)->active_connection;
}
/* From hostap, Copyright (c) 2002-2005, Jouni Malinen <jkmaline@cc.hut.fi> */

20
libnm-glib/nm-dhcp4-config.c
View file

@ -212,24 +212,10 @@ nm_dhcp4_config_new (DBusGConnection *connection, const char *object_path)
GHashTable *
nm_dhcp4_config_get_options (NMDHCP4Config *config)
{
NMDHCP4ConfigPrivate *priv = NM_DHCP4_CONFIG_GET_PRIVATE (config);
GValue value = { 0, };
g_return_val_if_fail (NM_IS_DHCP4_CONFIG (config), NULL);
if (g_hash_table_size (priv->options))
return priv->options;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_DHCP4_CONFIG,
"Options",
&value,
NULL))
goto out;
demarshal_dhcp4_options (NM_OBJECT (config), NULL, &value, &priv->options);
g_value_unset (&value);
out:
return priv->options;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_DHCP4_CONFIG_GET_PRIVATE (config)->options;
}
/**

20
libnm-glib/nm-dhcp6-config.c
View file

@ -212,24 +212,10 @@ nm_dhcp6_config_new (DBusGConnection *connection, const char *object_path)
GHashTable *
nm_dhcp6_config_get_options (NMDHCP6Config *config)
{
NMDHCP6ConfigPrivate *priv = NM_DHCP6_CONFIG_GET_PRIVATE (config);
GValue value = { 0, };
g_return_val_if_fail (NM_IS_DHCP6_CONFIG (config), NULL);
if (g_hash_table_size (priv->options))
return priv->options;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_DHCP6_CONFIG,
"Options",
&value,
NULL))
goto out;
demarshal_dhcp6_options (NM_OBJECT (config), NULL, &value, &priv->options);
g_value_unset (&value);
out:
return priv->options;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_DHCP6_CONFIG_GET_PRIVATE (config)->options;
}
/**

114
libnm-glib/nm-ip4-config.c
View file

@ -326,27 +326,10 @@ nm_ip4_config_new (DBusGConnection *connection, const char *object_path)
const GSList *
nm_ip4_config_get_addresses (NMIP4Config *config)
{
NMIP4ConfigPrivate *priv;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
priv = NM_IP4_CONFIG_GET_PRIVATE (config);
if (priv->addresses)
return priv->addresses;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP4_CONFIG,
"Addresses",
&value,
NULL)) {
return NULL;
}
demarshal_ip4_address_array (NM_OBJECT (config), NULL, &value, &priv->addresses);
g_value_unset (&value);
return priv->addresses;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->addresses;
}
/**
@ -361,29 +344,10 @@ nm_ip4_config_get_addresses (NMIP4Config *config)
const GArray *
nm_ip4_config_get_nameservers (NMIP4Config *config)
{
NMIP4ConfigPrivate *priv;
GArray *array = NULL;
GValue value = {0,};
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
priv = NM_IP4_CONFIG_GET_PRIVATE (config);
if (!priv->nameservers) {
if (_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP4_CONFIG,
"Nameservers",
&value,
NULL)) {
array = (GArray *) g_value_get_boxed (&value);
if (array && array->len) {
priv->nameservers = g_array_sized_new (FALSE, TRUE, sizeof (guint32), array->len);
g_array_append_vals (priv->nameservers, array->data, array->len);
}
g_value_unset (&value);
}
}
return priv->nameservers;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->nameservers;
}
/**
@ -398,32 +362,10 @@ nm_ip4_config_get_nameservers (NMIP4Config *config)
const GPtrArray *
nm_ip4_config_get_domains (NMIP4Config *config)
{
NMIP4ConfigPrivate *priv;
GValue value = {0,};
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
priv = NM_IP4_CONFIG_GET_PRIVATE (config);
if (priv->domains)
return handle_ptr_array_return (priv->domains);
if (_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP4_CONFIG,
"Domains",
&value,
NULL)) {
char **array = NULL, **p;
array = (char **) g_value_get_boxed (&value);
if (array && g_strv_length (array)) {
priv->domains = g_ptr_array_sized_new (g_strv_length (array));
for (p = array; *p; p++)
g_ptr_array_add (priv->domains, g_strdup (*p));
}
g_value_unset (&value);
}
return handle_ptr_array_return (priv->domains);
_nm_object_ensure_inited (NM_OBJECT (config));
return handle_ptr_array_return (NM_IP4_CONFIG_GET_PRIVATE (config)->domains);
}
/**
@ -438,29 +380,10 @@ nm_ip4_config_get_domains (NMIP4Config *config)
const GArray *
nm_ip4_config_get_wins_servers (NMIP4Config *config)
{
NMIP4ConfigPrivate *priv;
GArray *array = NULL;
GValue value = {0,};
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
priv = NM_IP4_CONFIG_GET_PRIVATE (config);
if (!priv->wins) {
if (_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP4_CONFIG,
"WinsServers",
&value,
NULL)) {
array = (GArray *) g_value_get_boxed (&value);
if (array && array->len) {
priv->wins = g_array_sized_new (FALSE, TRUE, sizeof (guint32), array->len);
g_array_append_vals (priv->wins, array->data, array->len);
}
g_value_unset (&value);
}
}
return priv->wins;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->wins;
}
/**
@ -476,26 +399,9 @@ nm_ip4_config_get_wins_servers (NMIP4Config *config)
const GSList *
nm_ip4_config_get_routes (NMIP4Config *config)
{
NMIP4ConfigPrivate *priv;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_IP4_CONFIG (config), NULL);
priv = NM_IP4_CONFIG_GET_PRIVATE (config);
if (priv->routes)
return priv->routes;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP4_CONFIG,
"Routes",
&value,
NULL)) {
return NULL;
}
demarshal_ip4_routes_array (NM_OBJECT (config), NULL, &value, &priv->routes);
g_value_unset (&value);
return priv->routes;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP4_CONFIG_GET_PRIVATE (config)->routes;
}

86
libnm-glib/nm-ip6-config.c
View file

@ -153,27 +153,10 @@ register_properties (NMIP6Config *config)
const GSList *
nm_ip6_config_get_addresses (NMIP6Config *config)
{
NMIP6ConfigPrivate *priv;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
priv = NM_IP6_CONFIG_GET_PRIVATE (config);
if (priv->addresses)
return priv->addresses;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP6_CONFIG,
"Addresses",
&value,
NULL)) {
return NULL;
}
demarshal_ip6_address_array (NM_OBJECT (config), NULL, &value, &priv->addresses);
g_value_unset (&value);
return priv->addresses;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->addresses;
}
/* FIXME: like in libnm_util, in6_addr is not introspectable, so skipping here */
@ -190,29 +173,10 @@ nm_ip6_config_get_addresses (NMIP6Config *config)
const GSList *
nm_ip6_config_get_nameservers (NMIP6Config *config)
{
NMIP6ConfigPrivate *priv;
GParamSpec *pspec;
GValue value = {0,};
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
priv = NM_IP6_CONFIG_GET_PRIVATE (config);
if (priv->nameservers)
return priv->nameservers;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP6_CONFIG,
"Nameservers",
&value,
NULL)) {
return NULL;
}
pspec = g_object_class_find_property (G_OBJECT_GET_CLASS (G_OBJECT (config)), NM_IP6_CONFIG_NAMESERVERS);
demarshal_ip6_nameserver_array (NM_OBJECT (config), pspec, &value, &priv->nameservers);
g_value_unset (&value);
return priv->nameservers;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->nameservers;
}
/**
@ -227,27 +191,10 @@ nm_ip6_config_get_nameservers (NMIP6Config *config)
const GPtrArray *
nm_ip6_config_get_domains (NMIP6Config *config)
{
NMIP6ConfigPrivate *priv;
GValue value = {0,};
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
priv = NM_IP6_CONFIG_GET_PRIVATE (config);
if (priv->domains)
return handle_ptr_array_return (priv->domains);
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP6_CONFIG,
"Domains",
&value,
NULL)) {
return NULL;
}
demarshal_domains (NM_OBJECT (config), NULL, &value, &priv->domains);
g_value_unset (&value);
return handle_ptr_array_return (priv->domains);
_nm_object_ensure_inited (NM_OBJECT (config));
return handle_ptr_array_return (NM_IP6_CONFIG_GET_PRIVATE (config)->domains);
}
/**
@ -263,27 +210,10 @@ nm_ip6_config_get_domains (NMIP6Config *config)
const GSList *
nm_ip6_config_get_routes (NMIP6Config *config)
{
NMIP6ConfigPrivate *priv;
GValue value = { 0, };
g_return_val_if_fail (NM_IS_IP6_CONFIG (config), NULL);
priv = NM_IP6_CONFIG_GET_PRIVATE (config);
if (priv->routes)
return priv->routes;
if (!_nm_object_get_property (NM_OBJECT (config),
NM_DBUS_INTERFACE_IP6_CONFIG,
"Routes",
&value,
NULL)) {
return NULL;
}
demarshal_ip6_routes_array (NM_OBJECT (config), NULL, &value, &priv->routes);
g_value_unset (&value);
return priv->routes;
_nm_object_ensure_inited (NM_OBJECT (config));
return NM_IP6_CONFIG_GET_PRIVATE (config)->routes;
}
static GObject*

52
libnm-glib/nm-object-private.h
View file

@ -27,6 +27,8 @@
#include <glib-object.h>
#include "nm-object.h"
void _nm_object_ensure_inited (NMObject *object);
typedef gboolean (*PropertyMarshalFunc) (NMObject *, GParamSpec *, GValue *, gpointer);
typedef GObject * (*NMObjectCreatorFunc) (DBusGConnection *, const char *);
@ -41,63 +43,23 @@ void _nm_object_register_properties (NMObject *object,
DBusGProxy *proxy,
const NMPropertiesInfo *info);
gboolean _nm_object_reload_properties (NMObject *object, GError **error);
void _nm_object_process_properties_changed (NMObject *self, GHashTable *properties);
void _nm_object_queue_notify (NMObject *object, const char *property);
/* DBus property accessors */
gboolean _nm_object_get_property (NMObject *object,
const char *interface,
const char *prop_name,
GValue *value,
GError **error);
void _nm_object_reload_property (NMObject *object,
const char *interface,
const char *prop_name);
void _nm_object_set_property (NMObject *object,
const char *interface,
const char *prop_name,
GValue *value);
char *_nm_object_get_string_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
char *_nm_object_get_object_path_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
gint32 _nm_object_get_int_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
guint32 _nm_object_get_uint_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
gboolean _nm_object_get_boolean_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
gint8 _nm_object_get_byte_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
gdouble _nm_object_get_double_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
GByteArray *_nm_object_get_byte_array_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error);
static inline const GPtrArray *
handle_ptr_array_return (GPtrArray *array)
{

232
libnm-glib/nm-object.c
View file

@ -52,7 +52,7 @@ typedef struct {
GSList *notify_props;
guint32 notify_id;
gboolean disposed;
gboolean inited, disposed;
} NMObjectPrivate;
enum {
@ -515,33 +515,71 @@ _nm_object_register_properties (NMObject *object,
}
gboolean
_nm_object_get_property (NMObject *object,
const char *interface,
const char *prop_name,
GValue *value,
GError **error)
_nm_object_reload_properties (NMObject *object, GError **error)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (object);
GHashTable *props = NULL;
GSList *p;
if (!priv->property_interfaces)
return TRUE;
priv->inited = TRUE;
for (p = priv->property_interfaces; p; p = p->next) {
if (!dbus_g_proxy_call (priv->properties_proxy, "GetAll", error,
G_TYPE_STRING, p->data,
G_TYPE_INVALID,
DBUS_TYPE_G_MAP_OF_VARIANT, &props,
G_TYPE_INVALID))
return FALSE;
_nm_object_process_properties_changed (object, props);
g_hash_table_destroy (props);
}
return TRUE;
}
void
_nm_object_ensure_inited (NMObject *object)
{
NMObjectPrivate *priv = NM_OBJECT_GET_PRIVATE (object);
GError *error = NULL;
if (!priv->inited) {
if (!_nm_object_reload_properties (object, &error)) {
g_warning ("Could not initialize %s %s: %s",
G_OBJECT_TYPE_NAME (object), priv->path,
error->message);
g_error_free (error);
}
}
}
void
_nm_object_reload_property (NMObject *object,
const char *interface,
const char *prop_name)
{
GValue value = { 0, };
GError *err = NULL;
g_return_val_if_fail (NM_IS_OBJECT (object), FALSE);
g_return_val_if_fail (interface != NULL, FALSE);
g_return_val_if_fail (prop_name != NULL, FALSE);
g_return_val_if_fail (value != NULL, FALSE);
g_return_val_if_fail (error == NULL || *error == NULL, FALSE);
g_return_if_fail (NM_IS_OBJECT (object));
g_return_if_fail (interface != NULL);
g_return_if_fail (prop_name != NULL);
if (!dbus_g_proxy_call_with_timeout (NM_OBJECT_GET_PRIVATE (object)->properties_proxy,
"Get", 15000, &err,
G_TYPE_STRING, interface,
G_TYPE_STRING, prop_name,
G_TYPE_INVALID,
G_TYPE_VALUE, value,
G_TYPE_VALUE, &value,
G_TYPE_INVALID)) {
/* Don't warn about D-Bus no reply/timeout errors; it's mostly noise and
* happens for example when NM quits and the applet is still running.
* And don't warn when 'error' is not NULL, rather propagate 'err' so the caller
* can do something with it. */
if ( !error
&& !(err->domain == DBUS_GERROR && err->code == DBUS_GERROR_NO_REPLY)) {
*/
if (!g_error_matches (err, DBUS_GERROR, DBUS_GERROR_NO_REPLY)) {
g_warning ("%s: Error getting '%s' for %s: (%d) %s\n",
__func__,
prop_name,
@ -549,11 +587,12 @@ _nm_object_get_property (NMObject *object,
err->code,
err->message);
}
g_propagate_error (error, err);
return FALSE;
g_clear_error (&err);
return;
}
return TRUE;
handle_property_changed ((gpointer)prop_name, &value, object);
g_value_unset (&value);
}
void
@ -579,158 +618,3 @@ _nm_object_set_property (NMObject *object,
*/
}
}
char *
_nm_object_get_string_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
char *str = NULL;
const char *tmp;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
if (G_VALUE_HOLDS_STRING (&value))
str = g_strdup (g_value_get_string (&value));
else if (G_VALUE_HOLDS (&value, DBUS_TYPE_G_OBJECT_PATH)) {
tmp = g_value_get_boxed (&value);
/* Handle "NULL" object paths */
if (g_strcmp0 (tmp, "/") != 0)
str = g_strdup (tmp);
}
g_value_unset (&value);
}
return str;
}
char *
_nm_object_get_object_path_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
char *path = NULL;
const char *tmp;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
tmp = g_value_get_boxed (&value);
if (g_strcmp0 (tmp, "/") != 0)
path = g_strdup (tmp);
g_value_unset (&value);
}
return path;
}
gint32
_nm_object_get_int_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
gint32 i = 0;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
i = g_value_get_int (&value);
g_value_unset (&value);
}
return i;
}
guint32
_nm_object_get_uint_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
guint32 i = 0;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
i = g_value_get_uint (&value);
g_value_unset (&value);
}
return i;
}
gboolean
_nm_object_get_boolean_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
gboolean b = FALSE;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
b = g_value_get_boolean (&value);
g_value_unset (&value);
}
return b;
}
gint8
_nm_object_get_byte_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
gint8 b = G_MAXINT8;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
b = g_value_get_uchar (&value);
g_value_unset (&value);
}
return b;
}
gdouble
_nm_object_get_double_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
gdouble d = G_MAXDOUBLE;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
d = g_value_get_double (&value);
g_value_unset (&value);
}
return d;
}
GByteArray *
_nm_object_get_byte_array_property (NMObject *object,
const char *interface,
const char *prop_name,
GError **error)
{
GByteArray *array = NULL;
GValue value = {0,};
if (_nm_object_get_property (object, interface, prop_name, &value, error)) {
GArray * tmp = g_value_get_boxed (&value);
int i;
unsigned char byte;
array = g_byte_array_sized_new (tmp->len);
for (i = 0; i < tmp->len; i++) {
byte = g_array_index (tmp, unsigned char, i);
g_byte_array_append (array, &byte, 1);
}
g_value_unset (&value);
}
return array;
}

24
libnm-glib/nm-vpn-connection.c
View file

@ -99,21 +99,11 @@ nm_vpn_connection_get_banner (NMVPNConnection *vpn)
priv = NM_VPN_CONNECTION_GET_PRIVATE (vpn);
/* We need to update vpn_state first in case it's unknown. */
nm_vpn_connection_get_vpn_state (vpn);
_nm_object_ensure_inited (NM_OBJECT (vpn));
if (priv->vpn_state != NM_VPN_CONNECTION_STATE_ACTIVATED)
return NULL;
if (!priv->banner) {
priv->banner = _nm_object_get_string_property (NM_OBJECT (vpn),
NM_DBUS_INTERFACE_VPN_CONNECTION,
DBUS_PROP_BANNER,
NULL);
if (priv->banner && !strlen (priv->banner)) {
g_free (priv->banner);
priv->banner = NULL;
}
}
return priv->banner;
}
@ -128,18 +118,10 @@ nm_vpn_connection_get_banner (NMVPNConnection *vpn)
NMVPNConnectionState
nm_vpn_connection_get_vpn_state (NMVPNConnection *vpn)
{
NMVPNConnectionPrivate *priv;
g_return_val_if_fail (NM_IS_VPN_CONNECTION (vpn), NM_VPN_CONNECTION_STATE_UNKNOWN);
priv = NM_VPN_CONNECTION_GET_PRIVATE (vpn);
if (priv->vpn_state == NM_VPN_CONNECTION_STATE_UNKNOWN) {
priv->vpn_state = _nm_object_get_uint_property (NM_OBJECT (vpn),
NM_DBUS_INTERFACE_VPN_CONNECTION,
DBUS_PROP_VPN_STATE,
NULL);
}
return priv->vpn_state;
_nm_object_ensure_inited (NM_OBJECT (vpn));
return NM_VPN_CONNECTION_GET_PRIVATE (vpn)->vpn_state;
}
static void

38
libnm-glib/nm-wimax-nsp.c
View file

@ -90,18 +90,10 @@ nm_wimax_nsp_new (DBusGConnection *connection, const char *path)
const char *
nm_wimax_nsp_get_name (NMWimaxNsp *nsp)
{
NMWimaxNspPrivate *priv;
g_return_val_if_fail (NM_IS_WIMAX_NSP (nsp), NULL);
priv = NM_WIMAX_NSP_GET_PRIVATE (nsp);
if (!priv->name)
priv->name = _nm_object_get_string_property (NM_OBJECT (nsp),
NM_DBUS_INTERFACE_WIMAX_NSP,
DBUS_PROP_NAME,
NULL);
return priv->name;
_nm_object_ensure_inited (NM_OBJECT (nsp));
return NM_WIMAX_NSP_GET_PRIVATE (nsp)->name;
}
/**
@ -115,19 +107,10 @@ nm_wimax_nsp_get_name (NMWimaxNsp *nsp)
guint32
nm_wimax_nsp_get_signal_quality (NMWimaxNsp *nsp)
{
NMWimaxNspPrivate *priv;
g_return_val_if_fail (NM_IS_WIMAX_NSP (nsp), 0);
priv = NM_WIMAX_NSP_GET_PRIVATE (nsp);
if (!priv->signal_quality) {
priv->signal_quality = _nm_object_get_uint_property (NM_OBJECT (nsp),
NM_DBUS_INTERFACE_WIMAX_NSP,
DBUS_PROP_SIGNAL_QUALITY,
NULL);
}
return priv->signal_quality;
_nm_object_ensure_inited (NM_OBJECT (nsp));
return NM_WIMAX_NSP_GET_PRIVATE (nsp)->signal_quality;
}
/**
@ -141,19 +124,10 @@ nm_wimax_nsp_get_signal_quality (NMWimaxNsp *nsp)
NMWimaxNspNetworkType
nm_wimax_nsp_get_network_type (NMWimaxNsp *nsp)
{
NMWimaxNspPrivate *priv;
g_return_val_if_fail (NM_IS_WIMAX_NSP (nsp), NM_WIMAX_NSP_NETWORK_TYPE_UNKNOWN);
priv = NM_WIMAX_NSP_GET_PRIVATE (nsp);
if (!priv->network_type) {
priv->network_type = _nm_object_get_uint_property (NM_OBJECT (nsp),
NM_DBUS_INTERFACE_WIMAX_NSP,
DBUS_PROP_NETWORK_TYPE,
NULL);
}
return priv->network_type;
_nm_object_ensure_inited (NM_OBJECT (nsp));
return NM_WIMAX_NSP_GET_PRIVATE (nsp)->network_type;
}
/**