← Back to branch summary

~ubuntu-branches/ubuntu/precise/network-manager/precise

« back to all changes in this revision

Viewing changes to libnm-glib/nm-device-wifi.c

  • Committer: Package Import Robot
  • Author(s): Mathieu Trudel-Lapierre
  • Date: 2012-02-09 16:45:41 UTC
  • mfrom: (1.1.53)
  • Revision ID: package-import@ubuntu.com-20120209164541-4h90zknlsfdb7x35
Tags: 0.9.2.0+git201202091925.c721477-0ubuntu1
* upstream snapshot 2012-02-09 19:25:59 (GMT)
  + c721477d11d4fe144111d6d2eec8f93f2e9186c9
* debian/patches/avoid-periodic-disk-wakeups.patch: refreshed.
* debian/patches/nl3-default-ip6-route.patch: refreshed.
* debian/libnm-glib4.symbols: add symbols:
  + nm_active_connection_get_master@Base
  + nm_client_new_async@Base
  + nm_client_new_finish@Base
  + nm_remote_settings_new_async@Base
  + nm_remote_settings_new_finish@Base
  + nm_device_get_state_reason@Base
* debian/libnm-util2.symbols: add symbols:
  + nm_setting_802_1x_get_pac_file@Base
  + nm_setting_infiniband_get_transport_mode@Base

Show diffs side-by-side

added added

removed removed

Lines of Context:
libnm-glib/nm-device-wifi.c
36
36
#include "nm-dbus-glib-types.h"
37
37
#include "nm-types-private.h"
38
38
 
39
 
#include "nm-device-wifi-bindings.h"
40
 
 
41
39
G_DEFINE_TYPE (NMDeviceWifi, nm_device_wifi, NM_TYPE_DEVICE)
42
40
 
43
41
#define NM_DEVICE_WIFI_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE_WIFI, NMDeviceWifiPrivate))
44
42
 
45
 
static gboolean demarshal_active_ap (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field);
46
 
 
47
43
void _nm_device_wifi_set_wireless_enabled (NMDeviceWifi *device, gboolean enabled);
48
44
 
49
45
typedef struct {
55
51
        NM80211Mode mode;
56
52
        guint32 rate;
57
53
        NMAccessPoint *active_ap;
58
 
        gboolean got_active_ap;
59
54
        NMDeviceWifiCapabilities wireless_caps;
60
55
        GPtrArray *aps;
61
56
 
102
97
GObject *
103
98
nm_device_wifi_new (DBusGConnection *connection, const char *path)
104
99
{
 
100
        GObject *device;
 
101
 
105
102
        g_return_val_if_fail (connection != NULL, NULL);
106
103
        g_return_val_if_fail (path != NULL, NULL);
107
104
 
108
 
        return g_object_new (NM_TYPE_DEVICE_WIFI,
109
 
                             NM_OBJECT_DBUS_CONNECTION, connection,
110
 
                             NM_OBJECT_DBUS_PATH, path,
111
 
                             NULL);
 
105
        device = g_object_new (NM_TYPE_DEVICE_WIFI,
 
106
                               NM_OBJECT_DBUS_CONNECTION, connection,
 
107
                               NM_OBJECT_DBUS_PATH, path,
 
108
                               NULL);
 
109
        _nm_object_ensure_inited (NM_OBJECT (device));
 
110
        return device;
112
111
}
113
112
 
114
113
/**
123
122
const char *
124
123
nm_device_wifi_get_hw_address (NMDeviceWifi *device)
125
124
{
126
 
        NMDeviceWifiPrivate *priv;
127
 
 
128
125
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
129
126
 
130
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
131
 
        if (!priv->hw_address) {
132
 
                priv->hw_address = _nm_object_get_string_property (NM_OBJECT (device),
133
 
                                                                  NM_DBUS_INTERFACE_DEVICE_WIRELESS,
134
 
                                                                  DBUS_PROP_HW_ADDRESS,
135
 
                                                                  NULL);
136
 
        }
137
 
 
138
 
        return priv->hw_address;
 
127
        _nm_object_ensure_inited (NM_OBJECT (device));
 
128
        return NM_DEVICE_WIFI_GET_PRIVATE (device)->hw_address;
139
129
}
140
130
 
141
131
/**
150
140
const char *
151
141
nm_device_wifi_get_permanent_hw_address (NMDeviceWifi *device)
152
142
{
153
 
        NMDeviceWifiPrivate *priv;
154
 
 
155
143
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
156
144
 
157
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
158
 
        if (!priv->perm_hw_address) {
159
 
                priv->perm_hw_address = _nm_object_get_string_property (NM_OBJECT (device),
160
 
                                                                        NM_DBUS_INTERFACE_DEVICE_WIRELESS,
161
 
                                                                        DBUS_PROP_PERM_HW_ADDRESS,
162
 
                                                                        NULL);
163
 
        }
164
 
 
165
 
        return priv->perm_hw_address;
 
145
        _nm_object_ensure_inited (NM_OBJECT (device));
 
146
        return NM_DEVICE_WIFI_GET_PRIVATE (device)->perm_hw_address;
166
147
}
167
148
 
168
149
/**
176
157
NM80211Mode
177
158
nm_device_wifi_get_mode (NMDeviceWifi *device)
178
159
{
179
 
        NMDeviceWifiPrivate *priv;
180
 
 
181
160
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
182
161
 
183
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
184
 
        if (!priv->mode) {
185
 
                priv->mode = _nm_object_get_uint_property (NM_OBJECT (device),
186
 
                                                          NM_DBUS_INTERFACE_DEVICE_WIRELESS,
187
 
                                                          DBUS_PROP_MODE,
188
 
                                                          NULL);
189
 
        }
190
 
 
191
 
        return priv->mode;
 
162
        _nm_object_ensure_inited (NM_OBJECT (device));
 
163
        return NM_DEVICE_WIFI_GET_PRIVATE (device)->mode;
192
164
}
193
165
 
194
166
/**
202
174
guint32
203
175
nm_device_wifi_get_bitrate (NMDeviceWifi *device)
204
176
{
205
 
        NMDeviceWifiPrivate *priv;
206
177
        NMDeviceState state;
207
178
 
208
179
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
219
190
                return 0;
220
191
        }
221
192
 
222
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
223
 
        if (!priv->rate) {
224
 
                priv->rate = _nm_object_get_uint_property (NM_OBJECT (device),
225
 
                                                         NM_DBUS_INTERFACE_DEVICE_WIRELESS,
226
 
                                                         DBUS_PROP_BITRATE,
227
 
                                                         NULL);
228
 
        }
229
 
 
230
 
        return priv->rate;
 
193
        _nm_object_ensure_inited (NM_OBJECT (device));
 
194
        return NM_DEVICE_WIFI_GET_PRIVATE (device)->rate;
231
195
}
232
196
 
233
197
/**
241
205
NMDeviceWifiCapabilities
242
206
nm_device_wifi_get_capabilities (NMDeviceWifi *device)
243
207
{
244
 
        NMDeviceWifiPrivate *priv;
245
 
 
246
208
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), 0);
247
209
 
248
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
249
 
        if (!priv->wireless_caps) {
250
 
                priv->wireless_caps = _nm_object_get_uint_property (NM_OBJECT (device),
251
 
                                                                   NM_DBUS_INTERFACE_DEVICE_WIRELESS,
252
 
                                                                   DBUS_PROP_WIRELESS_CAPABILITIES,
253
 
                                                                   NULL);
254
 
        }
255
 
 
256
 
        return priv->wireless_caps;
 
210
        _nm_object_ensure_inited (NM_OBJECT (device));
 
211
        return NM_DEVICE_WIFI_GET_PRIVATE (device)->wireless_caps;
257
212
}
258
213
 
259
214
/**
267
222
NMAccessPoint *
268
223
nm_device_wifi_get_active_access_point (NMDeviceWifi *device)
269
224
{
270
 
        NMDeviceWifiPrivate *priv;
271
225
        NMDeviceState state;
272
 
        char *path;
273
 
        GValue value = { 0, };
274
 
        GError *error = NULL;
275
226
 
276
227
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
277
228
 
291
242
                break;
292
243
        }
293
244
 
294
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
295
 
        if (priv->got_active_ap == TRUE)
296
 
                return priv->active_ap;
297
 
 
298
 
        path = _nm_object_get_object_path_property (NM_OBJECT (device),
299
 
                                                    NM_DBUS_INTERFACE_DEVICE_WIRELESS,
300
 
                                                    DBUS_PROP_ACTIVE_ACCESS_POINT,
301
 
                                                    &error);
302
 
        if (error == NULL) {
303
 
                g_value_init (&value, DBUS_TYPE_G_OBJECT_PATH);
304
 
                g_value_take_boxed (&value, path);
305
 
                demarshal_active_ap (NM_OBJECT (device), NULL, &value, &priv->active_ap);
306
 
                g_value_unset (&value);
307
 
        }
308
 
        g_clear_error (&error);
309
 
 
310
 
        return priv->active_ap;
 
245
        _nm_object_ensure_inited (NM_OBJECT (device));
 
246
        return NM_DEVICE_WIFI_GET_PRIVATE (device)->active_ap;
311
247
}
312
248
 
313
249
/**
323
259
const GPtrArray *
324
260
nm_device_wifi_get_access_points (NMDeviceWifi *device)
325
261
{
326
 
        NMDeviceWifiPrivate *priv;
327
 
        DBusGConnection *connection;
328
 
        GValue value = { 0, };
329
 
        GError *error = NULL;
330
 
        GPtrArray *temp;
331
 
 
332
262
        g_return_val_if_fail (NM_IS_DEVICE_WIFI (device), NULL);
333
263
 
334
 
        priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
335
 
        if (priv->aps)
336
 
                return handle_ptr_array_return (priv->aps);
337
 
 
338
 
        if (!org_freedesktop_NetworkManager_Device_Wireless_get_access_points (priv->proxy, &temp, &error)) {
339
 
                g_warning ("%s: error getting access points: %s", __func__, error->message);
340
 
                g_error_free (error);
341
 
                return NULL;
342
 
        }
343
 
 
344
 
        g_value_init (&value, DBUS_TYPE_G_ARRAY_OF_OBJECT_PATH);
345
 
        g_value_take_boxed (&value, temp);
346
 
        connection = nm_object_get_connection (NM_OBJECT (device));
347
 
        _nm_object_array_demarshal (&value, &priv->aps, connection, nm_access_point_new);
348
 
        g_value_unset (&value);
349
 
 
350
 
        return handle_ptr_array_return (priv->aps);
 
264
        _nm_object_ensure_inited (NM_OBJECT (device));
 
265
        return handle_ptr_array_return (NM_DEVICE_WIFI_GET_PRIVATE (device)->aps);
351
266
}
352
267
 
353
268
/**
386
301
}
387
302
 
388
303
static void
389
 
access_point_added_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
 
304
access_point_added (NMObject *self, NMObject *ap)
390
305
{
391
 
        NMDeviceWifi *self = NM_DEVICE_WIFI (user_data);
392
 
        NMDeviceWifiPrivate *priv;
393
 
        GObject *ap;
394
 
 
395
 
        g_return_if_fail (self != NULL);
396
 
 
397
 
        ap = G_OBJECT (nm_device_wifi_get_access_point_by_path (self, path));
398
 
        if (!ap) {
399
 
                DBusGConnection *connection = nm_object_get_connection (NM_OBJECT (self));
400
 
 
401
 
                priv = NM_DEVICE_WIFI_GET_PRIVATE (self);
402
 
                ap = G_OBJECT (_nm_object_cache_get (path));
403
 
                if (ap) {
404
 
                        g_ptr_array_add (priv->aps, ap);
405
 
                } else {
406
 
                        ap = G_OBJECT (nm_access_point_new (connection, path));
407
 
                        if (ap)
408
 
                                g_ptr_array_add (priv->aps, ap);
409
 
                }
410
 
        }
411
 
 
412
 
        if (ap)
413
 
                g_signal_emit (self, signals[ACCESS_POINT_ADDED], 0, NM_ACCESS_POINT (ap));
 
306
        g_signal_emit (self, signals[ACCESS_POINT_ADDED], 0, ap);
414
307
}
415
308
 
416
309
static void
417
 
access_point_removed_proxy (DBusGProxy *proxy, char *path, gpointer user_data)
 
310
access_point_removed (NMObject *self_obj, NMObject *ap_obj)
418
311
{
419
 
        NMDeviceWifi *self = NM_DEVICE_WIFI (user_data);
 
312
        NMDeviceWifi *self = NM_DEVICE_WIFI (self_obj);
420
313
        NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (self);
421
 
        NMAccessPoint *ap;
422
 
 
423
 
        g_return_if_fail (self != NULL);
424
 
 
425
 
        ap = nm_device_wifi_get_access_point_by_path (self, path);
426
 
        if (ap) {
427
 
                if (ap == priv->active_ap) {
428
 
                        g_object_unref (priv->active_ap);
429
 
                        priv->active_ap = NULL;
430
 
                        _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT);
431
 
 
432
 
                        priv->rate = 0;
433
 
                        _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_BITRATE);
434
 
                }
435
 
 
436
 
                g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap);
437
 
                g_ptr_array_remove (priv->aps, ap);
438
 
                g_object_unref (G_OBJECT (ap));
 
314
        NMAccessPoint *ap = NM_ACCESS_POINT (ap_obj);
 
315
 
 
316
        if (ap == priv->active_ap) {
 
317
                g_object_unref (priv->active_ap);
 
318
                priv->active_ap = NULL;
 
319
                _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT);
 
320
 
 
321
                priv->rate = 0;
 
322
                _nm_object_queue_notify (NM_OBJECT (self), NM_DEVICE_WIFI_BITRATE);
439
323
        }
 
324
 
 
325
        g_signal_emit (self, signals[ACCESS_POINT_REMOVED], 0, ap);
440
326
}
441
327
 
442
328
static void
629
515
        }
630
516
}
631
517
 
632
 
static gboolean
633
 
demarshal_active_ap (NMObject *object, GParamSpec *pspec, GValue *value, gpointer field)
634
 
{
635
 
        NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (object);
636
 
        const char *path;
637
 
        NMAccessPoint *ap = NULL;
638
 
        DBusGConnection *connection;
639
 
 
640
 
        if (value) {
641
 
                if (!G_VALUE_HOLDS (value, DBUS_TYPE_G_OBJECT_PATH))
642
 
                        return FALSE;
643
 
 
644
 
                path = g_value_get_boxed (value);
645
 
                if (path) {
646
 
                        ap = NM_ACCESS_POINT (_nm_object_cache_get (path));
647
 
                        if (!ap) {
648
 
                                connection = nm_object_get_connection (object);
649
 
                                ap = NM_ACCESS_POINT (nm_access_point_new (connection, path));
650
 
                        }
651
 
                }
652
 
        }
653
 
 
654
 
        priv->got_active_ap = TRUE;
655
 
 
656
 
        if (priv->active_ap) {
657
 
                g_object_unref (priv->active_ap);
658
 
                priv->active_ap = NULL;
659
 
        }
660
 
 
661
 
        if (ap)
662
 
                priv->active_ap = ap;
663
 
 
664
 
        _nm_object_queue_notify (object, NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT);
665
 
        return TRUE;
666
 
}
667
 
 
668
518
static void
669
 
register_for_property_changed (NMDeviceWifi *device)
 
519
register_properties (NMDeviceWifi *device)
670
520
{
671
521
        NMDeviceWifiPrivate *priv = NM_DEVICE_WIFI_GET_PRIVATE (device);
672
 
        const NMPropertiesChangedInfo property_changed_info[] = {
673
 
                { NM_DEVICE_WIFI_HW_ADDRESS,           _nm_object_demarshal_generic, &priv->hw_address },
674
 
                { NM_DEVICE_WIFI_PERMANENT_HW_ADDRESS, _nm_object_demarshal_generic, &priv->perm_hw_address },
675
 
                { NM_DEVICE_WIFI_MODE,                 _nm_object_demarshal_generic, &priv->mode },
676
 
                { NM_DEVICE_WIFI_BITRATE,              _nm_object_demarshal_generic, &priv->rate },
677
 
                { NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT,  demarshal_active_ap,         &priv->active_ap },
678
 
                { NM_DEVICE_WIFI_CAPABILITIES,         _nm_object_demarshal_generic, &priv->wireless_caps },
 
522
        const NMPropertiesInfo property_info[] = {
 
523
                { NM_DEVICE_WIFI_HW_ADDRESS,           &priv->hw_address },
 
524
                { NM_DEVICE_WIFI_PERMANENT_HW_ADDRESS, &priv->perm_hw_address },
 
525
                { NM_DEVICE_WIFI_MODE,                 &priv->mode },
 
526
                { NM_DEVICE_WIFI_BITRATE,              &priv->rate },
 
527
                { NM_DEVICE_WIFI_ACTIVE_ACCESS_POINT,  &priv->active_ap, NULL, NM_TYPE_ACCESS_POINT },
 
528
                { NM_DEVICE_WIFI_CAPABILITIES,         &priv->wireless_caps },
679
529
                { NULL },
680
530
        };
681
531
 
682
 
        _nm_object_handle_properties_changed (NM_OBJECT (device),
 
532
        _nm_object_register_properties (NM_OBJECT (device),
 
533
                                        priv->proxy,
 
534
                                        property_info);
 
535
 
 
536
        _nm_object_register_pseudo_property (NM_OBJECT (device),
683
537
                                             priv->proxy,
684
 
                                             property_changed_info);
 
538
                                             "AccessPoints",
 
539
                                             &priv->aps,
 
540
                                             NM_TYPE_ACCESS_POINT,
 
541
                                             access_point_added,
 
542
                                             access_point_removed);
685
543
}
686
544
 
687
 
static GObject*
688
 
constructor (GType type,
689
 
                   guint n_construct_params,
690
 
                   GObjectConstructParam *construct_params)
 
545
static void
 
546
constructed (GObject *object)
691
547
{
692
 
        GObject *object;
693
548
        NMDeviceWifiPrivate *priv;
694
549
 
695
 
        object = G_OBJECT_CLASS (nm_device_wifi_parent_class)->constructor (type,
696
 
                                                                                                                                    n_construct_params,
697
 
                                                                                                                                    construct_params);
698
 
        if (!object)
699
 
                return NULL;
 
550
        G_OBJECT_CLASS (nm_device_wifi_parent_class)->constructed (object);
700
551
 
701
552
        priv = NM_DEVICE_WIFI_GET_PRIVATE (object);
702
553
 
705
556
                                                                                        nm_object_get_path (NM_OBJECT (object)),
706
557
                                                                                        NM_DBUS_INTERFACE_DEVICE_WIRELESS);
707
558
 
708
 
        dbus_g_proxy_add_signal (priv->proxy, "AccessPointAdded",
709
 
                                 DBUS_TYPE_G_OBJECT_PATH,
710
 
                                 G_TYPE_INVALID);
711
 
        dbus_g_proxy_connect_signal (priv->proxy, "AccessPointAdded",
712
 
                                                    G_CALLBACK (access_point_added_proxy),
713
 
                                                    object, NULL);
714
 
 
715
 
        dbus_g_proxy_add_signal (priv->proxy, "AccessPointRemoved",
716
 
                                 DBUS_TYPE_G_OBJECT_PATH,
717
 
                                 G_TYPE_INVALID);
718
 
        dbus_g_proxy_connect_signal (priv->proxy, "AccessPointRemoved",
719
 
                                                    G_CALLBACK (access_point_removed_proxy),
720
 
                                                    object, NULL);
721
 
 
722
 
        register_for_property_changed (NM_DEVICE_WIFI (object));
 
559
        register_properties (NM_DEVICE_WIFI (object));
723
560
 
724
561
        g_signal_connect (NM_DEVICE (object),
725
562
                          "notify::" NM_DEVICE_STATE,
726
563
                          G_CALLBACK (state_changed_cb),
727
564
                          NULL);
728
 
 
729
 
        /* Get initial access points to prevent possible errors on
730
 
         * AccessPointRemoved signal processing. We could make D-Bus
731
 
         * GetAccessPoints() call on a removed WiFi device object (when
732
 
         * AccessPointRemoved was triggered by removing the device).
733
 
         */
734
 
        nm_device_wifi_get_access_points (NM_DEVICE_WIFI (object));
735
 
 
736
 
        return object;
737
565
}
738
566
 
739
567
static void
774
602
        g_type_class_add_private (wifi_class, sizeof (NMDeviceWifiPrivate));
775
603
 
776
604
        /* virtual methods */
777
 
        object_class->constructor = constructor;
 
605
        object_class->constructed = constructed;
778
606
        object_class->get_property = get_property;
779
607
        object_class->dispose = dispose;
780
608
        object_class->finalize = finalize;