fdo-mirrors/NetworkManager
1
0
Fork 0
mirror of https://gitlab.freedesktop.org/NetworkManager/NetworkManager.git synced 2026-02-04 01:20:35 +01:00
Code Issues Projects Releases Packages Wiki Activity Actions

2007-10-05 Dan Williams <dcbw@redhat.com>

Browse source 
* libnm-glib/nm-device-802-11-wireless.c
		- Cache properties and update cached properties on D-Bus signals from NM



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2937 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Dan Williams 2007-10-05 20:54:13 +00:00
parent f60d0d930c
commit 1f2cdcab4d
2 changed files with 314 additions and 13 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

5
ChangeLog
View file

@ -1,3 +1,8 @@
2007-10-05 Dan Williams <dcbw@redhat.com>
* libnm-glib/nm-device-802-11-wireless.c
- Cache properties and update cached properties on D-Bus signals from NM
2007-10-05 Dan Williams <dcbw@redhat.com>
* src/nm-device-802-11-wireless.c

322
libnm-glib/nm-device-802-11-wireless.c
View file

@ -1,3 +1,5 @@
#include <iwlib.h>
#include "nm-device-802-11-wireless.h"
#include "nm-device-private.h"
@ -12,9 +14,38 @@ typedef struct {
gboolean have_ap_list;
GHashTable *aps;
char * hw_address;
int mode;
int rate;
NMAccessPoint *current_ap;
guint32 wireless_caps;
gboolean disposed;
} NMDevice80211WirelessPrivate;
enum {
PROP_0,
PROP_HW_ADDRESS,
PROP_MODE,
PROP_BITRATE,
PROP_ACTIVE_ACCESS_POINT,
PROP_WIRELESS_CAPABILITIES,
LAST_PROP
};
#define NM_DEVICE_802_11_WIRELESS_PROP_HW_ADDRESS "hw-address"
#define NM_DEVICE_802_11_WIRELESS_PROP_MODE "mode"
#define NM_DEVICE_802_11_WIRELESS_PROP_BITRATE "bitrate"
#define NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT "active-access-point"
#define NM_DEVICE_802_11_WIRELESS_PROP_WIRELESS_CAPABILITIES "wireless-capabilities"
#define DBUS_PROP_HW_ADDRESS "HwAddress"
#define DBUS_PROP_MODE "Mode"
#define DBUS_PROP_BITRATE "Bitrate"
#define DBUS_PROP_ACTIVE_ACCESS_POINT "ActiveAccessPoint"
#define DBUS_PROP_WIRELESS_CAPABILITIES "WirelessCapabilities"
enum {
ACCESS_POINT_ADDED,
ACCESS_POINT_REMOVED,
@ -26,6 +57,13 @@ static guint signals[LAST_SIGNAL] = { 0 };
static void access_point_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
static void access_point_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data);
static void properties_changed_proxy (DBusGProxy *proxy,
GHashTable *properties,
gpointer user_data);
static NMAccessPoint *get_access_point (NMDevice80211Wireless *device,
const char *path,
gboolean create_if_not_found);
static void
nm_device_802_11_wireless_init (NMDevice80211Wireless *device)
@ -38,6 +76,67 @@ nm_device_802_11_wireless_init (NMDevice80211Wireless *device)
(GDestroyNotify) g_object_unref);
}
static void
get_property (GObject *object,
guint prop_id,
GValue *value,
GParamSpec *pspec)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
switch (prop_id) {
case PROP_HW_ADDRESS:
g_value_set_string (value, priv->hw_address);
break;
case PROP_MODE:
g_value_set_int (value, priv->mode);
break;
case PROP_BITRATE:
g_value_set_int (value, priv->rate);
break;
case PROP_ACTIVE_ACCESS_POINT:
g_value_set_object (value, priv->current_ap);
break;
case PROP_WIRELESS_CAPABILITIES:
g_value_set_uint (value, priv->wireless_caps);
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
state_changed_cb (NMDevice *device, NMDeviceState state, gpointer user_data)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
switch (state) {
case NM_DEVICE_STATE_PREPARE:
case NM_DEVICE_STATE_CONFIG:
case NM_DEVICE_STATE_NEED_AUTH:
case NM_DEVICE_STATE_IP_CONFIG:
case NM_DEVICE_STATE_ACTIVATED:
break;
case NM_DEVICE_STATE_UNKNOWN:
case NM_DEVICE_STATE_DOWN:
case NM_DEVICE_STATE_DISCONNECTED:
case NM_DEVICE_STATE_FAILED:
case NM_DEVICE_STATE_CANCELLED:
default:
if (priv->current_ap) {
g_object_unref (priv->current_ap);
priv->current_ap = NULL;
g_object_notify (G_OBJECT (device), NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT);
}
if (priv->rate != 0) {
priv->rate = 0;
g_object_notify (G_OBJECT (device), NM_DEVICE_802_11_WIRELESS_PROP_BITRATE);
}
break;
}
}
static GObject*
constructor (GType type,
guint n_construct_params,
@ -59,16 +158,34 @@ constructor (GType type,
nm_object_get_path (NM_OBJECT (object)),
NM_DBUS_INTERFACE_DEVICE_WIRELESS);
dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointAdded", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointAdded",
DBUS_TYPE_G_OBJECT_PATH,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->wireless_proxy, "AccessPointAdded",
G_CALLBACK (access_point_added_proxy),
object, NULL);
dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointRemoved", DBUS_TYPE_G_OBJECT_PATH, G_TYPE_INVALID);
dbus_g_proxy_add_signal (priv->wireless_proxy, "AccessPointRemoved",
DBUS_TYPE_G_OBJECT_PATH,
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->wireless_proxy, "AccessPointRemoved",
G_CALLBACK (access_point_removed_proxy),
object, NULL);
dbus_g_proxy_add_signal (priv->wireless_proxy, "PropertiesChanged",
dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->wireless_proxy,
"PropertiesChanged",
G_CALLBACK (properties_changed_proxy),
NM_DEVICE_802_11_WIRELESS (object),
NULL);
g_signal_connect (NM_DEVICE (object),
"state-changed",
G_CALLBACK (state_changed_cb),
NULL);
return object;
}
@ -84,6 +201,12 @@ dispose (GObject *object)
g_object_unref (priv->wireless_proxy);
g_hash_table_destroy (priv->aps);
priv->aps = NULL;
if (priv->current_ap)
g_object_unref (priv->current_ap);
G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->dispose (object);
}
@ -92,7 +215,8 @@ finalize (GObject *object)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
g_hash_table_destroy (priv->aps);
if (priv->hw_address)
g_free (priv->hw_address);
G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->finalize (object);
}
@ -106,9 +230,51 @@ nm_device_802_11_wireless_class_init (NMDevice80211WirelessClass *device_class)
/* virtual methods */
object_class->constructor = constructor;
object_class->get_property = get_property;
object_class->dispose = dispose;
object_class->finalize = finalize;
/* properties */
g_object_class_install_property
(object_class, PROP_HW_ADDRESS,
g_param_spec_string (NM_DEVICE_802_11_WIRELESS_PROP_HW_ADDRESS,
"MAC Address",
"Hardware MAC address",
NULL,
G_PARAM_READABLE));
g_object_class_install_property
(object_class, PROP_MODE,
g_param_spec_int (NM_DEVICE_802_11_WIRELESS_PROP_MODE,
"Mode",
"Mode",
0, IW_MODE_INFRA, 0,
G_PARAM_READABLE));
g_object_class_install_property
(object_class, PROP_BITRATE,
g_param_spec_int (NM_DEVICE_802_11_WIRELESS_PROP_BITRATE,
"Bit Rate",
"Bit Rate",
0, G_MAXINT32, 0,
G_PARAM_READABLE));
g_object_class_install_property
(object_class, PROP_ACTIVE_ACCESS_POINT,
g_param_spec_object (NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT,
"Active Access Point",
"Active Access Point",
nm_access_point_get_type (),
G_PARAM_READABLE));
g_object_class_install_property
(object_class, PROP_WIRELESS_CAPABILITIES,
g_param_spec_uint (NM_DEVICE_802_11_WIRELESS_PROP_WIRELESS_CAPABILITIES,
"Wireless Capabilities",
"Wireless Capabilities",
0, G_MAXUINT32, 0,
G_PARAM_READABLE));
/* signals */
signals[ACCESS_POINT_ADDED] =
g_signal_new ("access-point-added",
@ -143,36 +309,146 @@ nm_device_802_11_wireless_new (DBusGConnection *connection, const char *path)
NULL);
}
static void
handle_property_changed (gpointer key, gpointer data, gpointer user_data)
{
NMDevice80211Wireless *self = NM_DEVICE_802_11_WIRELESS (user_data);
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (self);
char *g_propname = NULL;
GValue *value = (GValue *) data;
gboolean success = TRUE;
if (!strcmp (key, DBUS_PROP_HW_ADDRESS)) {
g_propname = NM_DEVICE_802_11_WIRELESS_PROP_HW_ADDRESS;
if (G_VALUE_HOLDS_STRING (value))
priv->hw_address = g_strdup (g_value_get_string (value));
} else if (!strcmp (key, DBUS_PROP_MODE)) {
g_propname = NM_DEVICE_802_11_WIRELESS_PROP_MODE;
if (G_VALUE_HOLDS_INT (value))
priv->mode = g_value_get_int (value);
} else if (!strcmp (key, DBUS_PROP_BITRATE)) {
g_propname = NM_DEVICE_802_11_WIRELESS_PROP_BITRATE;
if (G_VALUE_HOLDS_INT (value))
priv->rate = g_value_get_int (value);
} else if (!strcmp (key, DBUS_PROP_ACTIVE_ACCESS_POINT)) {
g_propname = NM_DEVICE_802_11_WIRELESS_PROP_ACTIVE_ACCESS_POINT;
if (G_VALUE_HOLDS_BOXED (value)) {
const char *path = g_value_get_boxed (value);
if (priv->current_ap) {
g_object_unref (priv->current_ap);
priv->current_ap = NULL;
}
if (path && (strcmp (path, "/") != 0)) {
priv->current_ap = get_access_point (self, (const char *) path, TRUE);
if (priv->current_ap)
g_object_ref (priv->current_ap);
}
}
} else if (!strcmp (key, DBUS_PROP_WIRELESS_CAPABILITIES)) {
g_propname = NM_DEVICE_802_11_WIRELESS_PROP_WIRELESS_CAPABILITIES;
if (G_VALUE_HOLDS_UINT (value))
priv->wireless_caps = g_value_get_uint (value);
} else {
success = FALSE;
}
if (success) {
g_object_notify (G_OBJECT (self), g_propname);
}
}
static void
properties_changed_proxy (DBusGProxy *proxy,
GHashTable *properties,
gpointer user_data)
{
NMDevice80211Wireless *self = NM_DEVICE_802_11_WIRELESS (user_data);
g_hash_table_foreach (properties, handle_property_changed, self);
}
char *
nm_device_802_11_wireless_get_hw_address (NMDevice80211Wireless *device)
{
NMDevice80211WirelessPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), NULL);
return nm_object_get_string_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "HwAddress");
priv = NM_DEVICE_802_11_WIRELESS_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);
}
return priv->hw_address;
}
int
nm_device_802_11_wireless_get_mode (NMDevice80211Wireless *device)
{
NMDevice80211WirelessPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
return nm_object_get_int_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "Mode");
priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
if (!priv->mode) {
priv->mode = nm_object_get_int_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_MODE);
}
return priv->mode;
}
int
nm_device_802_11_wireless_get_bitrate (NMDevice80211Wireless *device)
{
NMDevice80211WirelessPrivate *priv;
NMDeviceState state;
g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
return nm_object_get_int_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "Bitrate");
state = nm_device_get_state (NM_DEVICE (device));
switch (state) {
case NM_DEVICE_STATE_PREPARE:
case NM_DEVICE_STATE_CONFIG:
case NM_DEVICE_STATE_NEED_AUTH:
case NM_DEVICE_STATE_IP_CONFIG:
case NM_DEVICE_STATE_ACTIVATED:
break;
default:
return 0;
break;
}
priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
if (!priv->rate) {
priv->rate = nm_object_get_int_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_BITRATE);
}
return priv->rate;
}
guint32
nm_device_802_11_wireless_get_capabilities (NMDevice80211Wireless *device)
{
NMDevice80211WirelessPrivate *priv;
g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), 0);
return nm_object_get_uint_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "WirelessCapabilities");
priv = NM_DEVICE_802_11_WIRELESS_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);
}
return priv->wireless_caps;
}
static NMAccessPoint *
@ -194,18 +470,38 @@ get_access_point (NMDevice80211Wireless *device, const char *path, gboolean crea
NMAccessPoint *
nm_device_802_11_wireless_get_active_access_point (NMDevice80211Wireless *device)
{
char *path;
NMAccessPoint *ap = NULL;
NMDevice80211WirelessPrivate *priv;
NMDeviceState state;
g_return_val_if_fail (NM_IS_DEVICE_802_11_WIRELESS (device), NULL);
path = nm_object_get_object_path_property (NM_OBJECT (device), NM_DBUS_INTERFACE_DEVICE_WIRELESS, "ActiveAccessPoint");
if (path) {
ap = get_access_point (device, path, TRUE);
state = nm_device_get_state (NM_DEVICE (device));
switch (state) {
case NM_DEVICE_STATE_PREPARE:
case NM_DEVICE_STATE_CONFIG:
case NM_DEVICE_STATE_NEED_AUTH:
case NM_DEVICE_STATE_IP_CONFIG:
case NM_DEVICE_STATE_ACTIVATED:
break;
default:
return NULL;
break;
}
priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
if (!priv->current_ap) {
char *path;
path = nm_object_get_object_path_property (NM_OBJECT (device),
NM_DBUS_INTERFACE_DEVICE_WIRELESS,
DBUS_PROP_ACTIVE_ACCESS_POINT);
priv->current_ap = get_access_point (device, path, TRUE);
if (priv->current_ap)
g_object_ref (priv->current_ap);
g_free (path);
}
return ap;
return priv->current_ap;
}
NMAccessPoint *