← 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-ethernet.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-ethernet.c
33
33
#include "nm-device-private.h"
34
34
#include "nm-object-private.h"
35
35
 
36
 
#include "nm-device-ethernet-bindings.h"
37
 
 
38
36
G_DEFINE_TYPE (NMDeviceEthernet, nm_device_ethernet, NM_TYPE_DEVICE)
39
37
 
40
38
#define NM_DEVICE_ETHERNET_GET_PRIVATE(o) (G_TYPE_INSTANCE_GET_PRIVATE ((o), NM_TYPE_DEVICE_ETHERNET, NMDeviceEthernetPrivate))
46
44
        char *perm_hw_address;
47
45
        guint32 speed;
48
46
        gboolean carrier;
49
 
        gboolean carrier_valid;
50
47
 
51
48
        gboolean disposed;
52
49
} NMDeviceEthernetPrivate;
78
75
GObject *
79
76
nm_device_ethernet_new (DBusGConnection *connection, const char *path)
80
77
{
 
78
        GObject *device;
 
79
 
81
80
        g_return_val_if_fail (connection != NULL, NULL);
82
81
        g_return_val_if_fail (path != NULL, NULL);
83
82
 
84
 
        return g_object_new (NM_TYPE_DEVICE_ETHERNET,
85
 
                             NM_OBJECT_DBUS_CONNECTION, connection,
86
 
                             NM_OBJECT_DBUS_PATH, path,
87
 
                             NULL);
 
83
        device = g_object_new (NM_TYPE_DEVICE_ETHERNET,
 
84
                                                   NM_OBJECT_DBUS_CONNECTION, connection,
 
85
                                                   NM_OBJECT_DBUS_PATH, path,
 
86
                                                   NULL);
 
87
        _nm_object_ensure_inited (NM_OBJECT (device));
 
88
        return device;
88
89
}
89
90
 
90
91
/**
99
100
const char *
100
101
nm_device_ethernet_get_hw_address (NMDeviceEthernet *device)
101
102
{
102
 
        NMDeviceEthernetPrivate *priv;
103
 
 
104
103
        g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL);
105
104
 
106
 
        priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
107
 
        if (!priv->hw_address) {
108
 
                priv->hw_address = _nm_object_get_string_property (NM_OBJECT (device),
109
 
                                                                  NM_DBUS_INTERFACE_DEVICE_WIRED,
110
 
                                                                  DBUS_PROP_HW_ADDRESS,
111
 
                                                                  NULL);
112
 
        }
113
 
 
114
 
        return priv->hw_address;
 
105
        _nm_object_ensure_inited (NM_OBJECT (device));
 
106
        return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->hw_address;
115
107
}
116
108
 
117
109
/**
126
118
const char *
127
119
nm_device_ethernet_get_permanent_hw_address (NMDeviceEthernet *device)
128
120
{
129
 
        NMDeviceEthernetPrivate *priv;
130
 
 
131
121
        g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), NULL);
132
122
 
133
 
        priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
134
 
        if (!priv->perm_hw_address) {
135
 
                priv->perm_hw_address = _nm_object_get_string_property (NM_OBJECT (device),
136
 
                                                                        NM_DBUS_INTERFACE_DEVICE_WIRED,
137
 
                                                                        DBUS_PROP_PERM_HW_ADDRESS,
138
 
                                                                        NULL);
139
 
        }
140
 
 
141
 
        return priv->perm_hw_address;
 
123
        _nm_object_ensure_inited (NM_OBJECT (device));
 
124
        return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->perm_hw_address;
142
125
}
143
126
 
144
127
/**
152
135
guint32
153
136
nm_device_ethernet_get_speed (NMDeviceEthernet *device)
154
137
{
155
 
        NMDeviceEthernetPrivate *priv;
156
 
 
157
138
        g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), 0);
158
139
 
159
 
        priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
160
 
        if (!priv->speed) {
161
 
                priv->speed = _nm_object_get_uint_property (NM_OBJECT (device),
162
 
                                                           NM_DBUS_INTERFACE_DEVICE_WIRED,
163
 
                                                           DBUS_PROP_SPEED,
164
 
                                                           NULL);
165
 
        }
166
 
 
167
 
        return priv->speed;
 
140
        _nm_object_ensure_inited (NM_OBJECT (device));
 
141
        return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->speed;
168
142
}
169
143
 
170
144
/**
178
152
gboolean
179
153
nm_device_ethernet_get_carrier (NMDeviceEthernet *device)
180
154
{
181
 
        NMDeviceEthernetPrivate *priv;
182
 
 
183
155
        g_return_val_if_fail (NM_IS_DEVICE_ETHERNET (device), FALSE);
184
156
 
185
 
        priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
186
 
        if (!priv->carrier_valid) {
187
 
                priv->carrier = _nm_object_get_boolean_property (NM_OBJECT (device),
188
 
                                                                NM_DBUS_INTERFACE_DEVICE_WIRED,
189
 
                                                                DBUS_PROP_CARRIER,
190
 
                                                                NULL);
191
 
                priv->carrier_valid = TRUE;
192
 
        }
193
 
 
194
 
        return priv->carrier;
 
157
        _nm_object_ensure_inited (NM_OBJECT (device));
 
158
        return NM_DEVICE_ETHERNET_GET_PRIVATE (device)->carrier;
195
159
}
196
160
 
197
161
static gboolean
245
209
 
246
210
        priv->disposed = FALSE;
247
211
        priv->carrier = FALSE;
248
 
        priv->carrier_valid = FALSE;
249
212
}
250
213
 
251
214
static void
252
 
register_for_property_changed (NMDeviceEthernet *device)
 
215
register_properties (NMDeviceEthernet *device)
253
216
{
254
217
        NMDeviceEthernetPrivate *priv = NM_DEVICE_ETHERNET_GET_PRIVATE (device);
255
 
        const NMPropertiesChangedInfo property_changed_info[] = {
256
 
                { NM_DEVICE_ETHERNET_HW_ADDRESS,           _nm_object_demarshal_generic, &priv->hw_address },
257
 
                { NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS, _nm_object_demarshal_generic, &priv->perm_hw_address },
258
 
                { NM_DEVICE_ETHERNET_SPEED,                _nm_object_demarshal_generic, &priv->speed },
259
 
                { NM_DEVICE_ETHERNET_CARRIER,              _nm_object_demarshal_generic, &priv->carrier },
 
218
        const NMPropertiesInfo property_info[] = {
 
219
                { NM_DEVICE_ETHERNET_HW_ADDRESS,           &priv->hw_address },
 
220
                { NM_DEVICE_ETHERNET_PERMANENT_HW_ADDRESS, &priv->perm_hw_address },
 
221
                { NM_DEVICE_ETHERNET_SPEED,                &priv->speed },
 
222
                { NM_DEVICE_ETHERNET_CARRIER,              &priv->carrier },
260
223
                { NULL },
261
224
        };
262
225
 
263
 
        _nm_object_handle_properties_changed (NM_OBJECT (device),
264
 
                                             priv->proxy,
265
 
                                             property_changed_info);
 
226
        _nm_object_register_properties (NM_OBJECT (device),
 
227
                                        priv->proxy,
 
228
                                        property_info);
266
229
}
267
230
 
268
 
static GObject*
269
 
constructor (GType type,
270
 
                         guint n_construct_params,
271
 
                         GObjectConstructParam *construct_params)
 
231
static void
 
232
constructed (GObject *object)
272
233
{
273
 
        GObject *object;
274
234
        NMDeviceEthernetPrivate *priv;
275
235
 
276
 
        object = G_OBJECT_CLASS (nm_device_ethernet_parent_class)->constructor (type,
277
 
                                                                                                                                                                  n_construct_params,
278
 
                                                                                                                                                                  construct_params);
279
 
        if (!object)
280
 
                return NULL;
 
236
        G_OBJECT_CLASS (nm_device_ethernet_parent_class)->constructed (object);
281
237
 
282
238
        priv = NM_DEVICE_ETHERNET_GET_PRIVATE (object);
283
239
 
286
242
                                                 nm_object_get_path (NM_OBJECT (object)),
287
243
                                                 NM_DBUS_INTERFACE_DEVICE_WIRED);
288
244
 
289
 
        register_for_property_changed (NM_DEVICE_ETHERNET (object));
290
 
 
291
 
        return object;
 
245
        register_properties (NM_DEVICE_ETHERNET (object));
292
246
}
293
247
 
294
248
static void
355
309
        g_type_class_add_private (eth_class, sizeof (NMDeviceEthernetPrivate));
356
310
 
357
311
        /* virtual methods */
358
 
        object_class->constructor = constructor;
 
312
        object_class->constructed = constructed;
359
313
        object_class->dispose = dispose;
360
314
        object_class->finalize = finalize;
361
315
        object_class->get_property = get_property;