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

2007-10-12 Tambet Ingo <tambet@gmail.com>

Browse source 
Rework the "properties-changed" signal listening implementation.
        Add a generic implementation to NMObject class that listens for
        the signal and calls property setters of the target NMObject.

        * libnm-glib/nm-object.c (nm_object_handle_properties_changed):
        * Implement.

        * libnm-glib/nm-device-802-11-wireless.c: Move the GObject
        * consturction
        code to the end of file so that all the static functions are
available
        without extra declarations.
        Remove the "properties-changed" signal handling and use the
framework from
        NMObject.
        Implement property setters for properties that change with 
        "properties-changed" signal.

        * libnm-glib/nm-access-point.c: Ditto.



git-svn-id: http://svn-archive.gnome.org/svn/NetworkManager/trunk@2972 4912f4e0-d625-0410-9fb7-b9a5a253dbdc
This commit is contained in:
Tambet Ingo 2007-10-12 10:18:46 +00:00
parent 7ce5758207
commit 86306041af
7 changed files with 746 additions and 608 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

18
ChangeLog
View file

@ -1,3 +1,21 @@
2007-10-12 Tambet Ingo <tambet@gmail.com>
Rework the "properties-changed" signal listening implementation.
Add a generic implementation to NMObject class that listens for
the signal and calls property setters of the target NMObject.
* libnm-glib/nm-object.c (nm_object_handle_properties_changed): Implement.
* libnm-glib/nm-device-802-11-wireless.c: Move the GObject consturction
code to the end of file so that all the static functions are available
without extra declarations.
Remove the "properties-changed" signal handling and use the framework from
NMObject.
Implement property setters for properties that change with
"properties-changed" signal.
* libnm-glib/nm-access-point.c: Ditto.
2007-10-12 Tambet Ingo <tambet@gmail.com>
Rework the "properties-changed" signal implementation.

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

@ -1,3 +1,5 @@
/* -*- Mode: C; tab-width: 5; indent-tabs-mode: t; c-basic-offset: 5 -*- */
#include <iwlib.h>
#include "nm-access-point.h"
@ -38,16 +40,6 @@ enum {
LAST_PROP
};
#define NM_ACCESS_POINT_FLAGS "flags"
#define NM_ACCESS_POINT_WPA_FLAGS "wpa_flags"
#define NM_ACCESS_POINT_RSN_FLAGS "rsn_flags"
#define NM_ACCESS_POINT_SSID "ssid"
#define NM_ACCESS_POINT_FREQUENCY "frequency"
#define NM_ACCESS_POINT_HW_ADDRESS "hw_address"
#define NM_ACCESS_POINT_MODE "mode"
#define NM_ACCESS_POINT_RATE "rate"
#define NM_ACCESS_POINT_STRENGTH "strength"
#define DBUS_PROP_FLAGS "Flags"
#define DBUS_PROP_WPA_FLAGS "WpaFlags"
#define DBUS_PROP_RSN_FLAGS "RsnFlags"
@ -58,9 +50,261 @@ enum {
#define DBUS_PROP_RATE "Rate"
#define DBUS_PROP_STRENGTH "Strength"
static void properties_changed_proxy (DBusGProxy *proxy,
GHashTable *properties,
gpointer user_data);
NMAccessPoint *
nm_access_point_new (DBusGConnection *connection, const char *path)
{
return (NMAccessPoint *) g_object_new (NM_TYPE_ACCESS_POINT,
NM_OBJECT_CONNECTION, connection,
NM_OBJECT_PATH, path,
NULL);
}
static void
nm_access_point_set_flags (NMAccessPoint *ap, guint32 flags)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->flags = flags;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_FLAGS);
}
guint32
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);
}
return priv->flags;
}
static void
nm_access_point_set_wpa_flags (NMAccessPoint *ap, guint32 flags)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->wpa_flags = flags;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_WPA_FLAGS);
}
guint32
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);
}
return priv->wpa_flags;
}
static void
nm_access_point_set_rsn_flags (NMAccessPoint *ap, guint32 flags)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->rsn_flags = flags;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_RSN_FLAGS);
}
guint32
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);
}
return priv->rsn_flags;
}
static void
nm_access_point_set_ssid (NMAccessPoint *ap, GArray *ssid)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (priv->ssid) {
g_byte_array_free (priv->ssid, TRUE);
priv->ssid = NULL;
}
if (ssid && ssid->len > 0) {
priv->ssid = g_byte_array_sized_new (ssid->len);
priv->ssid->len = ssid->len;
memcpy (priv->ssid->data, ssid->data, ssid->len);
}
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_SSID);
}
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);
}
return priv->ssid;
}
static void
nm_access_point_set_frequency (NMAccessPoint *ap, guint32 frequency)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->frequency = frequency;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_FREQUENCY);
}
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);
}
return priv->frequency;
}
static void
nm_access_point_set_hw_address (NMAccessPoint *ap, const char *address)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
g_free (priv->hw_address);
priv->hw_address = address ? g_strdup (address) : NULL;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_HW_ADDRESS);
}
const char *
nm_access_point_get_hw_address (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->hw_address) {
priv->hw_address = nm_object_get_string_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_HW_ADDRESS);
}
return priv->hw_address;
}
static void
nm_access_point_set_mode (NMAccessPoint *ap, int mode)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->mode = mode;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_MODE);
}
int
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_int_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_MODE);
}
return priv->mode;
}
static void
nm_access_point_set_rate (NMAccessPoint *ap, guint32 rate)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->rate = rate;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_RATE);
}
guint32
nm_access_point_get_rate (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->rate) {
priv->rate = nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_RATE);
}
return priv->rate;
}
static void
nm_access_point_set_strength (NMAccessPoint *ap, gint8 strength)
{
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
priv->strength = strength;
g_object_notify (G_OBJECT (ap), NM_ACCESS_POINT_STRENGTH);
}
gint8
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);
}
return priv->strength;
}
/************************************************************/
static void
nm_access_point_init (NMAccessPoint *ap)
@ -95,6 +339,46 @@ finalize (GObject *object)
G_OBJECT_CLASS (nm_access_point_parent_class)->finalize (object);
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMAccessPoint *ap = NM_ACCESS_POINT (object);
switch (prop_id) {
case PROP_FLAGS:
nm_access_point_set_flags (ap, g_value_get_uint (value));
break;
case PROP_WPA_FLAGS:
nm_access_point_set_wpa_flags (ap, g_value_get_uint (value));
break;
case PROP_RSN_FLAGS:
nm_access_point_set_rsn_flags (ap, g_value_get_uint (value));
break;
case PROP_SSID:
nm_access_point_set_ssid (ap, (GArray *) g_value_get_boxed (value));
break;
case PROP_FREQUENCY:
nm_access_point_set_frequency (ap, g_value_get_uint (value));
break;
case PROP_HW_ADDRESS:
nm_access_point_set_hw_address (ap, g_value_get_string (value));
break;
case PROP_MODE:
nm_access_point_set_mode (ap, g_value_get_int (value));
break;
case PROP_RATE:
nm_access_point_set_rate (ap, g_value_get_uint (value));
break;
case PROP_STRENGTH:
nm_access_point_set_strength (ap, g_value_get_char (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
static void
get_property (GObject *object,
guint prop_id,
@ -154,26 +438,20 @@ constructor (GType type,
NMAccessPointPrivate *priv;
object = (NMObject *) G_OBJECT_CLASS (nm_access_point_parent_class)->constructor (type,
n_construct_params,
construct_params);
n_construct_params,
construct_params);
if (!object)
return NULL;
priv = NM_ACCESS_POINT_GET_PRIVATE (object);
priv->ap_proxy = dbus_g_proxy_new_for_name (nm_object_get_connection (object),
NM_DBUS_SERVICE,
nm_object_get_path (object),
NM_DBUS_INTERFACE_ACCESS_POINT);
NM_DBUS_SERVICE,
nm_object_get_path (object),
NM_DBUS_INTERFACE_ACCESS_POINT);
nm_object_handle_properties_changed (NM_OBJECT (object), priv->ap_proxy);
dbus_g_proxy_add_signal (priv->ap_proxy, "PropertiesChanged",
dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (priv->ap_proxy,
"PropertiesChanged",
G_CALLBACK (properties_changed_proxy),
NM_ACCESS_POINT (object),
NULL);
return G_OBJECT (object);
}
@ -187,6 +465,7 @@ nm_access_point_class_init (NMAccessPointClass *ap_class)
/* virtual methods */
object_class->constructor = constructor;
object_class->set_property = set_property;
object_class->get_property = get_property;
object_class->dispose = dispose;
object_class->finalize = finalize;
@ -200,7 +479,7 @@ nm_access_point_class_init (NMAccessPointClass *ap_class)
NM_802_11_AP_FLAGS_NONE,
NM_802_11_AP_FLAGS_PRIVACY,
NM_802_11_AP_FLAGS_NONE,
G_PARAM_READABLE));
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_WPA_FLAGS,
@ -208,7 +487,7 @@ nm_access_point_class_init (NMAccessPointClass *ap_class)
"WPA Flags",
"WPA Flags",
0, G_MAXUINT32, 0,
G_PARAM_READABLE));
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_RSN_FLAGS,
@ -216,301 +495,53 @@ nm_access_point_class_init (NMAccessPointClass *ap_class)
"RSN Flags",
"RSN Flags",
0, G_MAXUINT32, 0,
G_PARAM_READABLE));
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_SSID,
g_param_spec_boxed (NM_ACCESS_POINT_SSID,
"SSID",
"SSID",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READABLE));
g_param_spec_boxed (NM_ACCESS_POINT_SSID,
"SSID",
"SSID",
DBUS_TYPE_G_UCHAR_ARRAY,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_FREQUENCY,
g_param_spec_uint (NM_ACCESS_POINT_FREQUENCY,
"Frequency",
"Frequency",
0, 10000, 0,
G_PARAM_READABLE));
"Frequency",
"Frequency",
0, 10000, 0,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_HW_ADDRESS,
g_param_spec_string (NM_ACCESS_POINT_HW_ADDRESS,
"MAC Address",
"Hardware MAC address",
NULL,
G_PARAM_READABLE));
"MAC Address",
"Hardware MAC address",
NULL,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_MODE,
g_param_spec_int (NM_ACCESS_POINT_MODE,
"Mode",
"Mode",
IW_MODE_ADHOC, IW_MODE_INFRA, IW_MODE_INFRA,
G_PARAM_READABLE));
"Mode",
"Mode",
IW_MODE_ADHOC, IW_MODE_INFRA, IW_MODE_INFRA,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_RATE,
g_param_spec_uint (NM_ACCESS_POINT_RATE,
"Rate",
"Rate",
0, G_MAXUINT16, 0,
G_PARAM_READABLE));
"Rate",
"Rate",
0, G_MAXUINT16, 0,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_STRENGTH,
g_param_spec_char (NM_ACCESS_POINT_STRENGTH,
"Strength",
"Strength",
G_MININT8, G_MAXINT8, 0,
G_PARAM_READABLE));
}
NMAccessPoint *
nm_access_point_new (DBusGConnection *connection, const char *path)
{
return (NMAccessPoint *) g_object_new (NM_TYPE_ACCESS_POINT,
NM_OBJECT_CONNECTION, connection,
NM_OBJECT_PATH, path,
NULL);
}
static void
handle_property_changed (gpointer key, gpointer data, gpointer user_data)
{
NMAccessPoint *ap = NM_ACCESS_POINT (user_data);
NMAccessPointPrivate *priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
char *g_propname = NULL;
GValue *value = (GValue *) data;
gboolean success = TRUE;
if (!strcmp (key, DBUS_PROP_FLAGS)) {
g_propname = NM_ACCESS_POINT_FLAGS;
if (G_VALUE_HOLDS_UINT (value))
priv->flags = g_value_get_uint (value);
} else if (!strcmp (key, DBUS_PROP_WPA_FLAGS)) {
g_propname = NM_ACCESS_POINT_WPA_FLAGS;
if (G_VALUE_HOLDS_UINT (value))
priv->wpa_flags = g_value_get_uint (value);
} else if (!strcmp (key, DBUS_PROP_RSN_FLAGS)) {
g_propname = NM_ACCESS_POINT_RSN_FLAGS;
if (G_VALUE_HOLDS_UINT (value))
priv->rsn_flags = g_value_get_uint (value);
} else if (!strcmp (key, DBUS_PROP_SSID)) {
GArray * tmp = g_value_get_boxed (value);
g_propname = NM_ACCESS_POINT_SSID;
if (priv->ssid) {
g_byte_array_free (priv->ssid, TRUE);
priv->ssid = NULL;
}
if (tmp && tmp->len) {
int i;
unsigned char byte;
priv->ssid = 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 (priv->ssid, &byte, 1);
}
}
} else if (!strcmp (key, DBUS_PROP_FREQUENCY)) {
g_propname = NM_ACCESS_POINT_FREQUENCY;
if (G_VALUE_HOLDS_UINT (value))
priv->frequency = g_value_get_uint (value);
} else if (!strcmp (key, DBUS_PROP_HW_ADDRESS)) {
g_propname = NM_ACCESS_POINT_HW_ADDRESS;
if (priv->hw_address) {
g_free (priv->hw_address);
priv->hw_address = NULL;
}
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_ACCESS_POINT_MODE;
if (G_VALUE_HOLDS_UINT (value))
priv->mode = g_value_get_uint (value);
} else if (!strcmp (key, DBUS_PROP_RATE)) {
g_propname = NM_ACCESS_POINT_RATE;
if (G_VALUE_HOLDS_UINT (value))
priv->rate = g_value_get_uint (value);
} else if (!strcmp (key, DBUS_PROP_STRENGTH)) {
g_propname = NM_ACCESS_POINT_STRENGTH;
if (G_VALUE_HOLDS_UCHAR (value))
priv->strength = g_value_get_uchar (value);
} else {
success = FALSE;
}
if (success) {
g_object_notify (G_OBJECT (ap), g_propname);
}
}
static void
properties_changed_proxy (DBusGProxy *proxy,
GHashTable *properties,
gpointer user_data)
{
NMAccessPoint *ap = NM_ACCESS_POINT (user_data);
g_hash_table_foreach (properties, handle_property_changed, ap);
}
guint32
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);
}
return priv->flags;
}
guint32
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);
}
return priv->wpa_flags;
}
guint32
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);
}
return priv->rsn_flags;
}
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);
}
return priv->ssid;
}
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);
}
return priv->frequency;
}
const char *
nm_access_point_get_hw_address (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), NULL);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->hw_address) {
priv->hw_address = nm_object_get_string_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_HW_ADDRESS);
}
return priv->hw_address;
}
int
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_int_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_MODE);
}
return priv->mode;
}
guint32
nm_access_point_get_rate (NMAccessPoint *ap)
{
NMAccessPointPrivate *priv;
g_return_val_if_fail (NM_IS_ACCESS_POINT (ap), 0);
priv = NM_ACCESS_POINT_GET_PRIVATE (ap);
if (!priv->rate) {
priv->rate = nm_object_get_uint_property (NM_OBJECT (ap),
NM_DBUS_INTERFACE_ACCESS_POINT,
DBUS_PROP_RATE);
}
return priv->rate;
}
gint8
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);
}
return priv->strength;
"Strength",
"Strength",
G_MININT8, G_MAXINT8, 0,
G_PARAM_READWRITE));
}

10
libnm-glib/nm-access-point.h
View file

@ -14,6 +14,16 @@ G_BEGIN_DECLS
#define NM_IS_ACCESS_POINT_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), NM_TYPE_ACCESS_POINT))
#define NM_ACCESS_POINT_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_ACCESS_POINT, NMAccessPointClass))
#define NM_ACCESS_POINT_FLAGS "flags"
#define NM_ACCESS_POINT_WPA_FLAGS "wpa_flags"
#define NM_ACCESS_POINT_RSN_FLAGS "rsn_flags"
#define NM_ACCESS_POINT_SSID "ssid"
#define NM_ACCESS_POINT_FREQUENCY "frequency"
#define NM_ACCESS_POINT_HW_ADDRESS "hw_address"
#define NM_ACCESS_POINT_MODE "mode"
#define NM_ACCESS_POINT_RATE "rate"
#define NM_ACCESS_POINT_STRENGTH "strength"
typedef struct {
NMObject parent;
} NMAccessPoint;

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

@ -1,3 +1,4 @@
/* -*- Mode: C; tab-width: 5; indent-tabs-mode: t; c-basic-offset: 5 -*- */
#include <iwlib.h>
#include "nm-device-802-11-wireless.h"
@ -34,12 +35,6 @@ enum {
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"
@ -55,248 +50,6 @@ enum {
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)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
priv->disposed = FALSE;
priv->aps = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(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,
GObjectConstructParam *construct_params)
{
GObject *object;
NMDevice80211WirelessPrivate *priv;
object = G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->constructor (type,
n_construct_params,
construct_params);
if (!object)
return NULL;
priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
priv->wireless_proxy = dbus_g_proxy_new_for_name (nm_object_get_connection (NM_OBJECT (object)),
NM_DBUS_SERVICE,
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_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_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;
}
static void
dispose (GObject *object)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
if (priv->disposed)
return;
priv->disposed = TRUE;
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);
}
static void
finalize (GObject *object)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
if (priv->hw_address)
g_free (priv->hw_address);
G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->finalize (object);
}
static void
nm_device_802_11_wireless_class_init (NMDevice80211WirelessClass *device_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (device_class);
g_type_class_add_private (device_class, sizeof (NMDevice80211WirelessPrivate));
/* 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",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMDevice80211WirelessClass, access_point_added),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
signals[ACCESS_POINT_REMOVED] =
g_signal_new ("access-point-removed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMDevice80211WirelessClass, access_point_removed),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
}
NMDevice80211Wireless *
nm_device_802_11_wireless_new (DBusGConnection *connection, const char *path)
{
@ -304,69 +57,20 @@ nm_device_802_11_wireless_new (DBusGConnection *connection, const char *path)
g_return_val_if_fail (path != NULL, NULL);
return (NMDevice80211Wireless *) g_object_new (NM_TYPE_DEVICE_802_11_WIRELESS,
NM_OBJECT_CONNECTION, connection,
NM_OBJECT_PATH, path,
NULL);
NM_OBJECT_CONNECTION, connection,
NM_OBJECT_PATH, path,
NULL);
}
static void
handle_property_changed (gpointer key, gpointer data, gpointer user_data)
nm_device_802_11_wireless_set_hw_address (NMDevice80211Wireless *self,
const char *address)
{
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);
g_free (priv->hw_address);
priv->hw_address = g_strdup (address);
g_object_notify (G_OBJECT (self), NM_DEVICE_802_11_WIRELESS_HW_ADDRESS);
}
char *
@ -386,6 +90,15 @@ nm_device_802_11_wireless_get_hw_address (NMDevice80211Wireless *device)
return priv->hw_address;
}
static void
nm_device_802_11_wireless_set_mode (NMDevice80211Wireless *self, int mode)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (self);
priv->mode = mode;
g_object_notify (G_OBJECT (self), NM_DEVICE_802_11_WIRELESS_MODE);
}
int
nm_device_802_11_wireless_get_mode (NMDevice80211Wireless *device)
{
@ -403,6 +116,17 @@ nm_device_802_11_wireless_get_mode (NMDevice80211Wireless *device)
return priv->mode;
}
static void
nm_device_802_11_wireless_set_bitrate (NMDevice80211Wireless *self, int bitrate)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (self);
if (priv->rate != bitrate) {
priv->rate = bitrate;
g_object_notify (G_OBJECT (self), NM_DEVICE_802_11_WIRELESS_BITRATE);
}
}
int
nm_device_802_11_wireless_get_bitrate (NMDevice80211Wireless *device)
{
@ -434,6 +158,15 @@ nm_device_802_11_wireless_get_bitrate (NMDevice80211Wireless *device)
return priv->rate;
}
static void
nm_device_802_11_wireless_set_capabilities (NMDevice80211Wireless *self, guint caps)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (self);
priv->wireless_caps = caps;
g_object_notify (G_OBJECT (self), NM_DEVICE_802_11_WIRELESS_CAPABILITIES);
}
guint32
nm_device_802_11_wireless_get_capabilities (NMDevice80211Wireless *device)
{
@ -467,6 +200,29 @@ get_access_point (NMDevice80211Wireless *device, const char *path, gboolean crea
return ap;
}
static void
nm_device_802_11_wireless_set_active_ap (NMDevice80211Wireless *self,
const char *ap_path)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (self);
if (!priv->current_ap && !ap_path)
return;
if (priv->current_ap) {
g_object_unref (priv->current_ap);
priv->current_ap = NULL;
}
if (ap_path && (!strcmp (ap_path, "/"))) {
priv->current_ap = get_access_point (self, ap_path, TRUE);
if (priv->current_ap)
g_object_ref (priv->current_ap);
}
g_object_notify (G_OBJECT (self), NM_DEVICE_802_11_WIRELESS_ACTIVE_ACCESS_POINT);
}
NMAccessPoint *
nm_device_802_11_wireless_get_active_access_point (NMDevice80211Wireless *device)
{
@ -587,3 +343,252 @@ access_point_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
g_hash_table_remove (NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device)->aps, path);
}
}
/**************************************************************/
static void
nm_device_802_11_wireless_init (NMDevice80211Wireless *device)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (device);
priv->disposed = FALSE;
priv->aps = g_hash_table_new_full (g_str_hash, g_str_equal,
(GDestroyNotify) g_free,
(GDestroyNotify) g_object_unref);
}
static void
set_property (GObject *object, guint prop_id,
const GValue *value, GParamSpec *pspec)
{
NMDevice80211Wireless *device = NM_DEVICE_802_11_WIRELESS (object);
switch (prop_id) {
case PROP_HW_ADDRESS:
nm_device_802_11_wireless_set_hw_address (device, g_value_get_string (value));
break;
case PROP_MODE:
nm_device_802_11_wireless_set_mode (device, g_value_get_int (value));
break;
case PROP_BITRATE:
nm_device_802_11_wireless_set_bitrate (device, g_value_get_int (value));
break;
case PROP_ACTIVE_ACCESS_POINT:
nm_device_802_11_wireless_set_active_ap (device, (char *) g_value_get_boxed (value));
break;
case PROP_WIRELESS_CAPABILITIES:
nm_device_802_11_wireless_set_capabilities (device, g_value_get_uint (value));
break;
default:
G_OBJECT_WARN_INVALID_PROPERTY_ID (object, prop_id, pspec);
break;
}
}
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_boxed (value, priv->current_ap ? nm_object_get_path (NM_OBJECT (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)
{
NMDevice80211Wireless *self = NM_DEVICE_802_11_WIRELESS (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:
nm_device_802_11_wireless_set_active_ap (self, NULL);
nm_device_802_11_wireless_set_bitrate (self, 0);
break;
}
}
static GObject*
constructor (GType type,
guint n_construct_params,
GObjectConstructParam *construct_params)
{
GObject *object;
NMDevice80211WirelessPrivate *priv;
object = G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->constructor (type,
n_construct_params,
construct_params);
if (!object)
return NULL;
priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
priv->wireless_proxy = dbus_g_proxy_new_for_name (nm_object_get_connection (NM_OBJECT (object)),
NM_DBUS_SERVICE,
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_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_connect_signal (priv->wireless_proxy, "AccessPointRemoved",
G_CALLBACK (access_point_removed_proxy),
object, NULL);
nm_object_handle_properties_changed (NM_OBJECT (object), priv->wireless_proxy);
g_signal_connect (NM_DEVICE (object),
"state-changed",
G_CALLBACK (state_changed_cb),
NULL);
return object;
}
static void
dispose (GObject *object)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
if (priv->disposed)
return;
priv->disposed = TRUE;
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);
}
static void
finalize (GObject *object)
{
NMDevice80211WirelessPrivate *priv = NM_DEVICE_802_11_WIRELESS_GET_PRIVATE (object);
if (priv->hw_address)
g_free (priv->hw_address);
G_OBJECT_CLASS (nm_device_802_11_wireless_parent_class)->finalize (object);
}
static void
nm_device_802_11_wireless_class_init (NMDevice80211WirelessClass *device_class)
{
GObjectClass *object_class = G_OBJECT_CLASS (device_class);
g_type_class_add_private (device_class, sizeof (NMDevice80211WirelessPrivate));
/* virtual methods */
object_class->constructor = constructor;
object_class->set_property = set_property;
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_HW_ADDRESS,
"MAC Address",
"Hardware MAC address",
NULL,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_MODE,
g_param_spec_int (NM_DEVICE_802_11_WIRELESS_MODE,
"Mode",
"Mode",
0, IW_MODE_INFRA, 0,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_BITRATE,
g_param_spec_int (NM_DEVICE_802_11_WIRELESS_BITRATE,
"Bit Rate",
"Bit Rate",
0, G_MAXINT32, 0,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_ACTIVE_ACCESS_POINT,
g_param_spec_boxed (NM_DEVICE_802_11_WIRELESS_ACTIVE_ACCESS_POINT,
"Active Access Point",
"Active Access Point",
DBUS_TYPE_G_OBJECT_PATH,
G_PARAM_READWRITE));
g_object_class_install_property
(object_class, PROP_WIRELESS_CAPABILITIES,
g_param_spec_uint (NM_DEVICE_802_11_WIRELESS_CAPABILITIES,
"Wireless Capabilities",
"Wireless Capabilities",
0, G_MAXUINT32, 0,
G_PARAM_READWRITE));
/* signals */
signals[ACCESS_POINT_ADDED] =
g_signal_new ("access-point-added",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMDevice80211WirelessClass, access_point_added),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
signals[ACCESS_POINT_REMOVED] =
g_signal_new ("access-point-removed",
G_OBJECT_CLASS_TYPE (object_class),
G_SIGNAL_RUN_FIRST,
G_STRUCT_OFFSET (NMDevice80211WirelessClass, access_point_removed),
NULL, NULL,
g_cclosure_marshal_VOID__OBJECT,
G_TYPE_NONE, 1,
G_TYPE_OBJECT);
}

6
libnm-glib/nm-device-802-11-wireless.h
View file

@ -13,6 +13,12 @@ G_BEGIN_DECLS
#define NM_IS_DEVICE_802_11_WIRELESS_CLASS(klass) (G_TYPE_CHECK_CLASS_TYPE ((obj), NM_TYPE_DEVICE_802_11_WIRELESS))
#define NM_DEVICE_802_11_WIRELESS_GET_CLASS(obj) (G_TYPE_INSTANCE_GET_CLASS ((obj), NM_TYPE_DEVICE_802_11_WIRELESS, NMDevice80211WirelessClass))
#define NM_DEVICE_802_11_WIRELESS_HW_ADDRESS "hw-address"
#define NM_DEVICE_802_11_WIRELESS_MODE "mode"
#define NM_DEVICE_802_11_WIRELESS_BITRATE "bitrate"
#define NM_DEVICE_802_11_WIRELESS_ACTIVE_ACCESS_POINT "active-access-point"
#define NM_DEVICE_802_11_WIRELESS_CAPABILITIES "wireless-capabilities"
typedef struct {
NMDevice parent;
} NMDevice80211Wireless;

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

@ -1,3 +1,6 @@
/* -*- Mode: C; tab-width: 5; indent-tabs-mode: t; c-basic-offset: 5 -*- */
#include <nm-utils.h>
#include "nm-object.h"
#include "NetworkManager.h"
@ -170,6 +173,69 @@ nm_object_get_path (NMObject *object)
return NM_OBJECT_GET_PRIVATE (object)->path;
}
/* Stolen from dbus-glib */
char*
wincaps_to_uscore (const char *caps)
{
const char *p;
GString *str;
str = g_string_new (NULL);
p = caps;
while (*p) {
if (g_ascii_isupper (*p)) {
if (str->len > 0 && (str->len < 2 || str->str[str->len-2] != '_'))
g_string_append_c (str, '_');
g_string_append_c (str, g_ascii_tolower (*p));
} else
g_string_append_c (str, *p);
++p;
}
return g_string_free (str, FALSE);
}
static void
handle_property_changed (gpointer key, gpointer data, gpointer user_data)
{
GObject *object = G_OBJECT (user_data);
char *prop_name;
GValue *value = (GValue *) data;
prop_name = wincaps_to_uscore ((char *) key);
if (g_object_class_find_property (G_OBJECT_GET_CLASS (object), prop_name))
g_object_set_property (object, prop_name, value);
else
nm_warning ("Property '%s' change detected but can't be set", prop_name);
g_free (prop_name);
}
static void
properties_changed_proxy (DBusGProxy *proxy,
GHashTable *properties,
gpointer user_data)
{
GObject *object = G_OBJECT (user_data);
g_object_freeze_notify (object);
g_hash_table_foreach (properties, handle_property_changed, object);
g_object_thaw_notify (object);
}
void
nm_object_handle_properties_changed (NMObject *object, DBusGProxy *proxy)
{
dbus_g_proxy_add_signal (proxy, "PropertiesChanged",
dbus_g_type_get_map ("GHashTable", G_TYPE_STRING, G_TYPE_VALUE),
G_TYPE_INVALID);
dbus_g_proxy_connect_signal (proxy,
"PropertiesChanged",
G_CALLBACK (properties_changed_proxy),
object,
NULL);
}
gboolean
nm_object_get_property (NMObject *object,
@ -353,4 +419,3 @@ nm_object_get_byte_array_property (NMObject *object,
return array;
}

3
libnm-glib/nm-object.h
View file

@ -30,6 +30,9 @@ GType nm_object_get_type (void);
DBusGConnection *nm_object_get_connection (NMObject *object);
const char *nm_object_get_path (NMObject *object);
void nm_object_handle_properties_changed (NMObject *object,
DBusGProxy *proxy);
/* DBus property accessors */
gboolean nm_object_get_property (NMObject *object,